From 18c0eba5cac589731404d074c42a4386f7e49fdf Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 13 Apr 2023 15:08:46 -0400
Subject: [PATCH 01/31] Add WRITE_STL functionality for OBST.

---
 Manuals/FDS_User_Guide/FDS_User_Guide.tex |  21 ++--
 Source/cons.f90                           |   5 +-
 Source/dump.f90                           | 124 +++++++++++++++++++++-
 Source/main.f90                           |   5 +
 Source/prec.f90                           |   3 +
 Source/read.f90                           |   2 +-
 6 files changed, 148 insertions(+), 12 deletions(-)

diff --git a/Manuals/FDS_User_Guide/FDS_User_Guide.tex b/Manuals/FDS_User_Guide/FDS_User_Guide.tex
index c7f1661fe29..bea8f6e70aa 100644
--- a/Manuals/FDS_User_Guide/FDS_User_Guide.tex
+++ b/Manuals/FDS_User_Guide/FDS_User_Guide.tex
@@ -5137,7 +5137,7 @@ \subsection{Catalysts}
 
 Some reactions require the presence of a specific molecule to stabilize the reaction rather than any species as in a third body reaction. An example is given below:
 \begin{equation}\label{eq:catalyst}
-	\mathrm{a \, X + b \, Y + \, Z \rightarrow X_aY_b + Z }
+    \mathrm{a \, X + b \, Y + \, Z \rightarrow X_aY_b + Z }
 \end{equation}
 A catalyst can be specified by listing the catalyst species twice in {\ct SPEC\_ID\_NU} and giving the {\ct NU} values for each side of the equation. The reaction will move forward in FDS using the net {\ct NU} and the default value for {\ct NU\_S} will be the left-hand side stoichiometric coefficient. For a reverse reaction, the value or {\ct NU\_S} for the catalyst will be the right-hand side stoichiometric coefficient.
 
@@ -9291,6 +9291,10 @@ \section{Plot3D Static Data Dumps}
 
 Past versions of FDS (1-5) output Plot3D files by default. Now, you must specify the time interval between dumps using {\ct DT\_PL3D} on the {\ct DUMP} line.
 
+\section{Stereolithography (STL) Geometry Dump}
+\label{info:stl}
+
+Stereolithography (STL) is a commonly used file format in computer-aided design (CAD) programs. STL files represent the surface geometry of objects using a set of triangles. FDS will generate an STL representation of input obstructions for visualization in other software packages if {\ct WRITE\_STL=T} is included on the {\ct DUMP} line.
 
 \section{SMOKE3D: Realistic Smoke and Fire}
 \label{info:SMOKE3D}
@@ -11250,6 +11254,7 @@ \section{\texorpdfstring{{\tt DUMP}}{DUMP} (Output Parameters)}
 {\ct STATUS\_FILES}                 & Logical      & Section~\ref{info:DUMP}                &           & {\ct F}                        \\ \hline
 {\ct SUPPRESS\_DIAGNOSTICS}         & Logical      & Section~\ref{info:monitoring_progress} &           & {\ct F}                        \\ \hline
 {\ct VELOCITY\_ERROR\_FILE}         & Logical      & Section~\ref{info:TIMING}              &           & {\ct F}                        \\ \hline
+{\ct WRITE\_STL}                    & Logical      & Section~\ref{info:Paraview}            &           & {\ct F}                        \\ \hline
 {\ct WRITE\_XYZ}                    & Logical      & Section~\ref{info:PL3D}                &           & {\ct F}                        \\ \hline
 \end{longtable}
 
@@ -13387,16 +13392,16 @@ \section{FDS HVAC I/O binary format}
 \label{inout:binhvac}
 The HVAC outputs under the namelist group {\ct HVAC} are written out unformatted to the file {\ct CHID.hvac}. These files are written out from {\ct dump.f90} with the following lines:
 \begin{lstlisting}
-	WRITE(LU_HVAC) N_NODE_OUT, N_NODE_QUANTITY, N_DUCT_OUT, N_DUCT_QUANTITY
-	WRITE(LU_HVAC) DUCT_CELL(1:N_DUCT_OUT)
+    WRITE(LU_HVAC) N_NODE_OUT, N_NODE_QUANTITY, N_DUCT_OUT, N_DUCT_QUANTITY
+    WRITE(LU_HVAC) DUCT_CELL(1:N_DUCT_OUT)
 
-	WRITE(LU_HVAC) TIME
+    WRITE(LU_HVAC) TIME
     DO N=1,N_NODE_OUT
        WRITE(LU_HVAC) OUTVAL_N(1:N_NODE_QUANTITY)
     ENDDO
-	DO N=1,N_DUCT_OUT
-	   IF (DUCT(N)%N_CELLS > 0) THEN
-     	  DO N=1,DUCT(N)%N_CELLS
+    DO N=1,N_DUCT_OUT
+       IF (DUCT(N)%N_CELLS > 0) THEN
+          DO N=1,DUCT(N)%N_CELLS
              WRITE(LU_HVAC) OUTVAL_D(1:N_DUCT_QUANTITY)
           ENDDO
        ELSE
@@ -13421,7 +13426,7 @@ \chapter{Predefined Species}
 This appendix lists all predefined species in FDS. If a species name ends in 'p' or 'm', this indicates the positive or negative charge state of that species. If a species ends in 's', this indicates the excited state of that species. This is typically written with a '*' as in CH$^*$. A 'Y in the Liquid column indicates that liquid properties are predefined, and a 'Y' in the Gibbs column indicates that Gibbs energy data is predefined.
 
 \begin{landscape}
-	\IfFileExists{spec_table.tex}{\input{spec_table.tex}}{\typeout{Error: Missing file spec\_table.tex}}
+    \IfFileExists{spec_table.tex}{\input{spec_table.tex}}{\typeout{Error: Missing file spec\_table.tex}}
 \end{landscape}
 
 
diff --git a/Source/cons.f90 b/Source/cons.f90
index f0010cc0b73..18ee3aca03e 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -177,6 +177,7 @@ MODULE GLOBAL_CONSTANTS
 LOGICAL :: SUPPRESSION=.TRUE.               !< Indicates if gas-phase combustion extinction is modeled
 LOGICAL :: ACCUMULATE_WATER=.FALSE.         !< Indicates that integrated liquid outputs are specified
 LOGICAL :: WRITE_XYZ=.FALSE.                !< Indicates that a Plot3D geometry file is specified by user
+LOGICAL :: WRITE_STL=.FALSE.                !< Indicates that a STL geometry file is specified by user
 LOGICAL :: CHECK_POISSON=.FALSE.            !< Check the accuracy of the Poisson solver
 LOGICAL :: TWO_D=.FALSE.                    !< Perform a 2-D simulation
 LOGICAL :: SETUP_ONLY=.FALSE.               !< Indicates that the calculation should be stopped before time-stepping
@@ -523,7 +524,7 @@ MODULE GLOBAL_CONSTANTS
                                         LU_CATF=9
 INTEGER                              :: LU_MASS,LU_HRR,LU_STEPS,LU_NOTREADY,LU_VELOCITY_ERROR,LU_CFL,LU_LINE=-1,LU_CUTCELL
 INTEGER                              :: LU_HISTOGRAM,LU_HVAC
-INTEGER                              :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1
+INTEGER                              :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL
 INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART
 INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM
 INTEGER                              :: LU_GEOM_TRAN
@@ -534,7 +535,7 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(250)                             :: FN_INPUT='null'
 CHARACTER(80)                              :: FN_STOP='null',FN_CPU,FN_CFL,FN_OUTPUT='null'
 CHARACTER(80)                              :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT
-CHARACTER(80)                              :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC
+CHARACTER(80)                              :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDF_GEOM,FN_BNDG, &
diff --git a/Source/dump.f90 b/Source/dump.f90
index 938ff9885d3..3382e46364f 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -51,7 +51,7 @@ MODULE DUMP
        TIMINGS,FLUSH_GLOBAL_BUFFERS,FLUSH_LOCAL_BUFFERS,READ_RESTART,WRITE_DIAGNOSTICS, &
        WRITE_SMOKEVIEW_FILE,DUMP_MESH_OUTPUTS,UPDATE_GLOBAL_OUTPUTS,DUMP_DEVICES,DUMP_HRR,DUMP_MASS,DUMP_CONTROLS,&
        INITIALIZE_DIAGNOSTIC_FILE,DUMP_RESTART,DUMP_HVAC,&
-       DUMP_UVW,DUMP_GEOM,UPDATE_DEVICES_2,WRITE_DEVC_CTRL_LOG
+       DUMP_UVW,DUMP_GEOM,UPDATE_DEVICES_2,WRITE_DEVC_CTRL_LOG,WRITE_STL_FILE
 
 CONTAINS
 
@@ -509,6 +509,11 @@ SUBROUTINE ASSIGN_FILE_NAMES
    FN_DEVC_CTRL = TRIM(CHID)//'_devc_ctrl_log.csv'
 ENDIF
 
+IF (WRITE_STL) THEN
+   LU_STL = GET_FILE_NUMBER()
+   FN_STL = TRIM(CHID)//'.stl'
+ENDIF
+
 END SUBROUTINE ASSIGN_FILE_NAMES
 
 
@@ -1403,6 +1408,123 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM)
 T_USED(7) = T_USED(7) + CURRENT_TIME() - TNOW
 END SUBROUTINE INITIALIZE_MESH_DUMPS
 
+SUBROUTINE WRITE_STL_FILE
+   ! Parts of this subroutine use conent from stack overflow
+   ! Original question: https://stackoverflow.com/questions/34144786
+   ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21
+   !character(len=*), parameter :: fname = 'fds.stl'
+   INTEGER :: I,IOS,N,FACES(12, 3)
+   CHARACTER(LEN=80) :: title
+   REAL(FB) :: VERTICES(8,3), XB(6)
+   INTEGER(IB4) :: color(3), one
+   INTEGER(IB32) :: NUM_FACETS
+   
+   title = FN_STL
+    
+   FACES(1,:) = (/1,4,2/)
+   FACES(2,:) = (/2,4,3/)
+   FACES(3,:) = (/1,5,8/)
+   FACES(4,:) = (/1,8,4/)
+   FACES(5,:) = (/5,6,7/)
+   FACES(6,:) = (/5,7,8/)
+   FACES(7,:) = (/6,2,3/)
+   FACES(8,:) = (/6,3,7/)
+   FACES(9,:) = (/3,4,7/)
+   FACES(10,:) = (/4,8,7/)
+   FACES(11,:) = (/1,2,6/)
+   FACES(12,:) = (/1,6,5/)
+   
+   OPEN(UNIT=LU_STL, FILE=title, ACCESS='stream', STATUS='replace', &
+      ACTION='write', IOSTAT=IOS)
+   CALL check(IOS, 'open')
+   WRITE(LU_STL, IOStat=IOS) title
+   CALL check(IOS, 'write title')
+   NUM_FACETS = M%N_OBST*12
+   WRITE(LU_STL, IOStat=IOS) NUM_FACETS
+   CALL check(IOS, 'write number of facets')
+   
+   DO N=1,M%N_OBST
+      OB=>M%OBSTRUCTION(N)
+      XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/)
+      !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
+      !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3)
+      VERTICES = get_vertices(XB)
+    
+      DO I=1,12
+         !CALL write_facet_c(u, &
+         !   VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color)
+         CALL write_facet(LU_STL, &
+            VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:))
+      END DO
+
+   ENDDO
+   CLOSE(LU_STL, IOSTAT=IOS)
+   CALL check(IOS, 'close')
+CONTAINS
+
+   FUNCTION get_vertices(XB)
+      REAL(FB), INTENT(IN) :: XB(6)
+      REAL(FB) :: get_vertices(8,3)
+      get_vertices(1,:) = (/XB(1),XB(3),XB(5)/)
+      get_vertices(2,:) = (/XB(2),XB(3),XB(5)/)
+      get_vertices(3,:) = (/XB(2),XB(4),XB(5)/)
+      get_vertices(4,:) = (/XB(1),XB(4),XB(5)/)
+      get_vertices(5,:) = (/XB(1),XB(3),XB(6)/)
+      get_vertices(6,:) = (/XB(2),XB(3),XB(6)/)
+      get_vertices(7,:) = (/XB(2),XB(4),XB(6)/)
+      get_vertices(8,:) = (/XB(1),XB(4),XB(6)/)
+   END FUNCTION get_vertices
+    
+   SUBROUTINE check(IOS, operation)
+      IMPLICIT NONE
+      INTEGER, INTENT(IN) :: IOS
+      CHARACTER(LEN=*), INTENT(IN) :: operation
+      IF (IOS == 0) RETURN
+      WRITE(*, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", operation
+      STOP 1
+   END SUBROUTINE check
+
+   SUBROUTINE write_facet(u, vertex1, vertex2, vertex3)
+      IMPLICIT NONE
+      INTEGER, INTENT(IN) :: u
+      REAL(FB), DIMENSION(3), INTENT(IN) :: vertex1, vertex2, vertex3
+      REAL(FB), DIMENSION(3) :: normal
+      INTEGER(IB16), PARAMETER :: zero = 0
+      
+      normal = calc_normal(vertex1, vertex2, vertex3)
+      WRITE(u, IOSTAT=IOS) normal
+      CALL check(IOS, 'write normal')
+      WRITE(u, IOSTAT=IOS) vertex1
+      CALL check(IOS, 'write vertex')
+      WRITE(u, IOSTAT=IOS) vertex2
+      CALL check(IOS, 'write vertex')
+      WRITE(u, IOSTAT=IOS) vertex3
+      CALL check(IOS, 'write vertex')
+      WRITE(u, IOSTAT=IOS) zero
+      CALL check(IOS, 'write zero')
+   END SUBROUTINE write_facet
+
+   FUNCTION calc_normal(vec1, vec2, vec3)
+      IMPLICIT NONE
+      REAL(FB), DIMENSION(3), INTENT(IN) :: vec1, vec2, vec3
+      REAL(FB), DIMENSION(3) :: calc_normal
+      REAL(FB), DIMENSION(3) :: d1, d2
+      d1 = vec2 - vec1
+      d2 = vec3 - vec1
+      calc_normal(1) = d1(2) * d2(3) - d1(3) * d2(2)
+      calc_normal(2) = d1(3) * d2(1) - d1(1) * d2(3)
+      calc_normal(3) = d1(1) * d2(2) - d1(2) * d2(1)
+      calc_normal = calc_normal / norm(calc_normal)
+   END FUNCTION calc_normal
+
+   FUNCTION norm(vec)
+      IMPLICIT NONE
+      REAL(FB), DIMENSION(3), INTENT(IN) :: vec
+      REAL(FB) :: norm
+      norm = sqrt(vec(1)**2 + vec(2)**2 + vec(3)**2)
+   END FUNCTION norm
+
+END SUBROUTINE WRITE_STL_FILE
 
 !> \brief Write information into the Smokeview (.smv) file
 
diff --git a/Source/main.f90 b/Source/main.f90
index 986e410227c..9304bfbd819 100644
--- a/Source/main.f90
+++ b/Source/main.f90
@@ -146,6 +146,11 @@ PROGRAM FDS
    IF (SHARED_FILE_SYSTEM) CALL MPI_BARRIER(MPI_COMM_WORLD, IERR)
 ENDDO
 
+! Write STL file if required
+IF (WRITE_STL) THEN
+   CALL WRITE_STL_FILE
+ENDIF
+
 ! Shut down the run if it is only for checking the set up
 
 IF (SETUP_ONLY .AND. .NOT.CHECK_MESH_ALIGNMENT) STOP_STATUS = SETUP_ONLY_STOP
diff --git a/Source/prec.f90 b/Source/prec.f90
index ec20e2bf335..8749a160df0 100644
--- a/Source/prec.f90
+++ b/Source/prec.f90
@@ -6,6 +6,9 @@ MODULE PRECISION_PARAMETERS
 
 INTEGER, PARAMETER :: FB = SELECTED_REAL_KIND(6)     !< Precision of "Four Byte" reals
 INTEGER, PARAMETER :: EB = SELECTED_REAL_KIND(12)    !< Precision of "Eight Byte" reals
+INTEGER, PARAMETER :: IB4 = SELECTED_INT_KIND(1)     !< Precision of "One Byte" ints
+INTEGER, PARAMETER :: IB16 = SELECTED_INT_KIND(3)    !< Precision of "Two Byte" ints
+INTEGER, PARAMETER :: IB32 = SELECTED_INT_KIND(6)    !< Precision of "Four Byte" ints
 INTEGER, PARAMETER :: MAX_LPC=20                     !< Maximum number of declared particle classes
 INTEGER, PARAMETER :: MAX_SPECIES=20                 !< Maximum number of declared species
 INTEGER, PARAMETER :: MAX_LAYERS=20                  !< Maximum number of solid material layers
diff --git a/Source/read.f90 b/Source/read.f90
index 83f4efe2e90..37cec60cee6 100644
--- a/Source/read.f90
+++ b/Source/read.f90
@@ -2188,7 +2188,7 @@ SUBROUTINE READ_DUMP
                 RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_GEOM,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,&
                 RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,RAMP_UVW,&
                 RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,SUPPRESS_DIAGNOSTICS,&
-                TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ
+                TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL
 
 ! Set defaults
 

From c8f32655f955a727243d05c4a680f0dea9fb7e93 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 13 Apr 2023 15:54:04 -0400
Subject: [PATCH 02/31] Fix WRITE_STL for multiple meshes.

---
 Source/dump.f90 | 38 ++++++++++++++++++++++----------------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 3382e46364f..0a8685fb1d2 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -1413,7 +1413,7 @@ SUBROUTINE WRITE_STL_FILE
    ! Original question: https://stackoverflow.com/questions/34144786
    ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21
    !character(len=*), parameter :: fname = 'fds.stl'
-   INTEGER :: I,IOS,N,FACES(12, 3)
+   INTEGER :: I,IOS,N,NM,FACES(12, 3)
    CHARACTER(LEN=80) :: title
    REAL(FB) :: VERTICES(8,3), XB(6)
    INTEGER(IB4) :: color(3), one
@@ -1439,24 +1439,30 @@ SUBROUTINE WRITE_STL_FILE
    CALL check(IOS, 'open')
    WRITE(LU_STL, IOStat=IOS) title
    CALL check(IOS, 'write title')
-   NUM_FACETS = M%N_OBST*12
+   
+   NUM_FACETS = 0
+   DO NM=1,NMESHES
+      M => MESHES(NM)
+      NUM_FACETS = NUM_FACETS + M%N_OBST*12
+   END DO
    WRITE(LU_STL, IOStat=IOS) NUM_FACETS
    CALL check(IOS, 'write number of facets')
-   
-   DO N=1,M%N_OBST
-      OB=>M%OBSTRUCTION(N)
-      XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/)
-      !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
-      !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3)
-      VERTICES = get_vertices(XB)
-    
-      DO I=1,12
-         !CALL write_facet_c(u, &
-         !   VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color)
-         CALL write_facet(LU_STL, &
-            VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:))
+   DO NM=1,NMESHES
+      M => MESHES(NM)
+      DO N=1,M%N_OBST
+         OB=>M%OBSTRUCTION(N)
+         XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/)
+         !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
+         !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3)
+         VERTICES = get_vertices(XB)
+         
+         DO I=1,12
+            !CALL write_facet_c(u, &
+            !   VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color)
+            CALL write_facet(LU_STL, &
+               VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:))
+         END DO
       END DO
-
    ENDDO
    CLOSE(LU_STL, IOSTAT=IOS)
    CALL check(IOS, 'close')

From d99d6f8c3d6f9375eed8085cbd05593ee24d4a30 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 13 Apr 2023 16:07:57 -0400
Subject: [PATCH 03/31] Fix section reference for WRITE_STL.

---
 Manuals/FDS_User_Guide/FDS_User_Guide.tex | 2 +-
 Source/dump.f90                           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Manuals/FDS_User_Guide/FDS_User_Guide.tex b/Manuals/FDS_User_Guide/FDS_User_Guide.tex
index 431517db622..c7fe46672cb 100644
--- a/Manuals/FDS_User_Guide/FDS_User_Guide.tex
+++ b/Manuals/FDS_User_Guide/FDS_User_Guide.tex
@@ -11263,7 +11263,7 @@ \section{\texorpdfstring{{\tt DUMP}}{DUMP} (Output Parameters)}
 {\ct STATUS\_FILES}                 & Logical      & Section~\ref{info:DUMP}                &           & {\ct F}                        \\ \hline
 {\ct SUPPRESS\_DIAGNOSTICS}         & Logical      & Section~\ref{info:monitoring_progress} &           & {\ct F}                        \\ \hline
 {\ct VELOCITY\_ERROR\_FILE}         & Logical      & Section~\ref{info:TIMING}              &           & {\ct F}                        \\ \hline
-{\ct WRITE\_STL}                    & Logical      & Section~\ref{info:Paraview}            &           & {\ct F}                        \\ \hline
+{\ct WRITE\_STL}                    & Logical      & Section~\ref{info:stl}                 &           & {\ct F}                        \\ \hline
 {\ct WRITE\_XYZ}                    & Logical      & Section~\ref{info:PL3D}                &           & {\ct F}                        \\ \hline
 \end{longtable}
 
diff --git a/Source/dump.f90 b/Source/dump.f90
index 0a8685fb1d2..3524011fc5b 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -1409,7 +1409,7 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM)
 END SUBROUTINE INITIALIZE_MESH_DUMPS
 
 SUBROUTINE WRITE_STL_FILE
-   ! Parts of this subroutine use conent from stack overflow
+   ! Parts of this subroutine use content from stack overflow
    ! Original question: https://stackoverflow.com/questions/34144786
    ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21
    !character(len=*), parameter :: fname = 'fds.stl'

From 618493acc1af999cd9eb2cd941bfe8e0aa16872b Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Wed, 3 May 2023 18:35:39 -0400
Subject: [PATCH 04/31] Add geoms to WRITE_STL in dump.

---
 Source/dump.f90 | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 4727fa456d9..18de551d33b 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -27,6 +27,7 @@ MODULE DUMP
 CHARACTER(80) :: TCFORM
 LOGICAL :: EX,DRY,OPN,FROM_BNDF=.FALSE.
 
+TYPE (GEOMETRY_TYPE), POINTER :: G=>NULL()
 TYPE (MESH_TYPE), POINTER :: M=>NULL()
 TYPE (LAGRANGIAN_PARTICLE_TYPE), POINTER :: LP=>NULL()
 TYPE (OBSTRUCTION_TYPE), POINTER :: OB=>NULL()
@@ -1413,9 +1414,10 @@ SUBROUTINE WRITE_STL_FILE
    ! Original question: https://stackoverflow.com/questions/34144786
    ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21
    !character(len=*), parameter :: fname = 'fds.stl'
-   INTEGER :: I,IOS,N,NM,FACES(12, 3)
+   INTEGER :: I,IOS,N,NM,FACES(12, 3),GEOM_VERTICES_IDS(1,3)
    CHARACTER(LEN=80) :: title
    REAL(FB) :: VERTICES(8,3), XB(6)
+   REAL(FB) :: GEOM_VERTICES(3,3)
    INTEGER(IB4) :: color(3), one
    INTEGER(IB32) :: NUM_FACETS
    
@@ -1445,6 +1447,12 @@ SUBROUTINE WRITE_STL_FILE
       M => MESHES(NM)
       NUM_FACETS = NUM_FACETS + M%N_OBST*12
    END DO
+   
+   DO I= 1,N_GEOMETRY
+      G=>GEOMETRY(I)
+      NUM_FACETS = NUM_FACETS + G%N_FACES
+   END DO
+   
    WRITE(LU_STL, IOStat=IOS) NUM_FACETS
    CALL check(IOS, 'write number of facets')
    DO NM=1,NMESHES
@@ -1464,6 +1472,18 @@ SUBROUTINE WRITE_STL_FILE
          END DO
       END DO
    ENDDO
+   
+   DO I= 1,N_GEOMETRY
+      G=>GEOMETRY(I)
+      DO N=1,G%N_FACES
+         GEOM_VERTICES_IDS(1,:) = G%FACES((N-1)*3+1:(N-1)*3 + 3)
+         GEOM_VERTICES(1,:) = G%VERTS((GEOM_VERTICES_IDS(1,1)-1)*3+1:(GEOM_VERTICES_IDS(1,1)-1)*3+3)
+         GEOM_VERTICES(2,:) = G%VERTS((GEOM_VERTICES_IDS(1,2)-1)*3+1:(GEOM_VERTICES_IDS(1,2)-1)*3+3)
+         GEOM_VERTICES(3,:) = G%VERTS((GEOM_VERTICES_IDS(1,3)-1)*3+1:(GEOM_VERTICES_IDS(1,3)-1)*3+3)
+         CALL write_facet(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:))
+      ENDDO
+   ENDDO
+   
    CLOSE(LU_STL, IOSTAT=IOS)
    CALL check(IOS, 'close')
 CONTAINS

From e1e7551f5ea7178b47f01b35abb054bbfb3adcaf Mon Sep 17 00:00:00 2001
From: rmcdermo <randy.mcdermott@gmail.com>
Date: Mon, 8 May 2023 16:59:29 -0400
Subject: [PATCH 05/31] FDS Source: fix formatting and unused warning

---
 Source/dump.f90 | 133 +++++++++++++++++++++++++-----------------------
 1 file changed, 69 insertions(+), 64 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 9155b7f8c77..601d3f4d630 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -1409,19 +1409,23 @@ SUBROUTINE INITIALIZE_MESH_DUMPS(NM)
 T_USED(7) = T_USED(7) + CURRENT_TIME() - TNOW
 END SUBROUTINE INITIALIZE_MESH_DUMPS
 
+
 SUBROUTINE WRITE_STL_FILE
    ! Parts of this subroutine use content from stack overflow
    ! Original question: https://stackoverflow.com/questions/34144786
    ! User whos answer is integrated: https://stackoverflow.com/users/4621823/chw21
    !character(len=*), parameter :: fname = 'fds.stl'
    INTEGER :: I,IOS,N,NM,FACES(12, 3),GEOM_VERTICES_IDS(1,3)
-   CHARACTER(LEN=80) :: title
+   CHARACTER(LEN=80) :: TITLE
    REAL(FB) :: VERTICES(8,3), XB(6)
    REAL(FB) :: GEOM_VERTICES(3,3)
-   INTEGER(IB4) :: color(3), one
+   INTEGER(IB4) :: COLOR(3), ONE
    INTEGER(IB32) :: NUM_FACETS
+
+   COLOR = (/0,0,0/)
+   ONE   = 1
    
-   title = FN_STL
+   TITLE = FN_STL
     
    FACES(1,:) = (/1,4,2/)
    FACES(2,:) = (/2,4,3/)
@@ -1436,11 +1440,11 @@ SUBROUTINE WRITE_STL_FILE
    FACES(11,:) = (/1,2,6/)
    FACES(12,:) = (/1,6,5/)
    
-   OPEN(UNIT=LU_STL, FILE=title, ACCESS='stream', STATUS='replace', &
+   OPEN(UNIT=LU_STL, FILE=TITLE, ACCESS='stream', STATUS='replace', &
       ACTION='write', IOSTAT=IOS)
-   CALL check(IOS, 'open')
-   WRITE(LU_STL, IOStat=IOS) title
-   CALL check(IOS, 'write title')
+   CALL CHECK(IOS, 'open')
+   WRITE(LU_STL, IOStat=IOS) TITLE
+   CALL CHECK(IOS, 'write title')
    
    NUM_FACETS = 0
    DO NM=1,NMESHES
@@ -1454,20 +1458,20 @@ SUBROUTINE WRITE_STL_FILE
    END DO
    
    WRITE(LU_STL, IOStat=IOS) NUM_FACETS
-   CALL check(IOS, 'write number of facets')
+   CALL CHECK(IOS, 'write number of facets')
    DO NM=1,NMESHES
       M => MESHES(NM)
       DO N=1,M%N_OBST
          OB=>M%OBSTRUCTION(N)
          XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/)
-         !color(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
+         !COLOR(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
          !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3)
          VERTICES = get_vertices(XB)
          
          DO I=1,12
-            !CALL write_facet_c(u, &
+            !CALL write_facet_c(U, &
             !   VERTICES(FACES(i,1),:), VERTICES(FACES(i,2),:), VERTICES(FACES(i,3),:), color)
-            CALL write_facet(LU_STL, &
+            CALL WRITE_FACET(LU_STL, &
                VERTICES(FACES(I,1),:), VERTICES(FACES(I,2),:), VERTICES(FACES(I,3),:))
          END DO
       END DO
@@ -1480,75 +1484,76 @@ SUBROUTINE WRITE_STL_FILE
          GEOM_VERTICES(1,:) = G%VERTS((GEOM_VERTICES_IDS(1,1)-1)*3+1:(GEOM_VERTICES_IDS(1,1)-1)*3+3)
          GEOM_VERTICES(2,:) = G%VERTS((GEOM_VERTICES_IDS(1,2)-1)*3+1:(GEOM_VERTICES_IDS(1,2)-1)*3+3)
          GEOM_VERTICES(3,:) = G%VERTS((GEOM_VERTICES_IDS(1,3)-1)*3+1:(GEOM_VERTICES_IDS(1,3)-1)*3+3)
-         CALL write_facet(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:))
+         CALL WRITE_FACET(LU_STL, GEOM_VERTICES(1,:), GEOM_VERTICES(2,:), GEOM_VERTICES(3,:))
       ENDDO
    ENDDO
    
    CLOSE(LU_STL, IOSTAT=IOS)
-   CALL check(IOS, 'close')
+   CALL CHECK(IOS, 'close')
+
 CONTAINS
 
-   FUNCTION get_vertices(XB)
+   FUNCTION GET_VERTICES(XB)
       REAL(FB), INTENT(IN) :: XB(6)
-      REAL(FB) :: get_vertices(8,3)
-      get_vertices(1,:) = (/XB(1),XB(3),XB(5)/)
-      get_vertices(2,:) = (/XB(2),XB(3),XB(5)/)
-      get_vertices(3,:) = (/XB(2),XB(4),XB(5)/)
-      get_vertices(4,:) = (/XB(1),XB(4),XB(5)/)
-      get_vertices(5,:) = (/XB(1),XB(3),XB(6)/)
-      get_vertices(6,:) = (/XB(2),XB(3),XB(6)/)
-      get_vertices(7,:) = (/XB(2),XB(4),XB(6)/)
-      get_vertices(8,:) = (/XB(1),XB(4),XB(6)/)
-   END FUNCTION get_vertices
+      REAL(FB) :: GET_VERTICES(8,3)
+      GET_VERTICES(1,:) = (/XB(1),XB(3),XB(5)/)
+      GET_VERTICES(2,:) = (/XB(2),XB(3),XB(5)/)
+      GET_VERTICES(3,:) = (/XB(2),XB(4),XB(5)/)
+      GET_VERTICES(4,:) = (/XB(1),XB(4),XB(5)/)
+      GET_VERTICES(5,:) = (/XB(1),XB(3),XB(6)/)
+      GET_VERTICES(6,:) = (/XB(2),XB(3),XB(6)/)
+      GET_VERTICES(7,:) = (/XB(2),XB(4),XB(6)/)
+      GET_VERTICES(8,:) = (/XB(1),XB(4),XB(6)/)
+   END FUNCTION GET_VERTICES
     
-   SUBROUTINE check(IOS, operation)
+   SUBROUTINE CHECK(IOS, OPERATION)
       IMPLICIT NONE
       INTEGER, INTENT(IN) :: IOS
-      CHARACTER(LEN=*), INTENT(IN) :: operation
+      CHARACTER(LEN=*), INTENT(IN) :: OPERATION
       IF (IOS == 0) RETURN
-      WRITE(*, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", operation
+      WRITE(LU_ERR, '(A, I0, 2A)') "Encountered error ", IOS, " while performing ", OPERATION
       STOP 1
-   END SUBROUTINE check
+   END SUBROUTINE CHECK
 
-   SUBROUTINE write_facet(u, vertex1, vertex2, vertex3)
+   SUBROUTINE WRITE_FACET(U, VERTEX1, VERTEX2, VERTEX3)
       IMPLICIT NONE
-      INTEGER, INTENT(IN) :: u
-      REAL(FB), DIMENSION(3), INTENT(IN) :: vertex1, vertex2, vertex3
-      REAL(FB), DIMENSION(3) :: normal
-      INTEGER(IB16), PARAMETER :: zero = 0
-      
-      normal = calc_normal(vertex1, vertex2, vertex3)
-      WRITE(u, IOSTAT=IOS) normal
-      CALL check(IOS, 'write normal')
-      WRITE(u, IOSTAT=IOS) vertex1
-      CALL check(IOS, 'write vertex')
-      WRITE(u, IOSTAT=IOS) vertex2
-      CALL check(IOS, 'write vertex')
-      WRITE(u, IOSTAT=IOS) vertex3
-      CALL check(IOS, 'write vertex')
-      WRITE(u, IOSTAT=IOS) zero
-      CALL check(IOS, 'write zero')
-   END SUBROUTINE write_facet
-
-   FUNCTION calc_normal(vec1, vec2, vec3)
+      INTEGER, INTENT(IN) :: U
+      REAL(FB), DIMENSION(3), INTENT(IN) :: VERTEX1, VERTEX2, VERTEX3
+      REAL(FB), DIMENSION(3) :: NORMAL
+      INTEGER(IB16), PARAMETER :: ZERO = 0
+
+      NORMAL = CALC_NORMAL(VERTEX1, VERTEX2, VERTEX3)
+      WRITE(U, IOSTAT=IOS) NORMAL
+      CALL CHECK(IOS, 'WRITE NORMAL')
+      WRITE(U, IOSTAT=IOS) VERTEX1
+      CALL CHECK(IOS, 'WRITE VERTEX')
+      WRITE(U, IOSTAT=IOS) VERTEX2
+      CALL CHECK(IOS, 'WRITE VERTEX')
+      WRITE(U, IOSTAT=IOS) VERTEX3
+      CALL CHECK(IOS, 'WRITE VERTEX')
+      WRITE(U, IOSTAT=IOS) ZERO
+      CALL CHECK(IOS, 'WRITE ZERO')
+   END SUBROUTINE WRITE_FACET
+
+   FUNCTION CALC_NORMAL(VEC1, VEC2, VEC3)
       IMPLICIT NONE
-      REAL(FB), DIMENSION(3), INTENT(IN) :: vec1, vec2, vec3
-      REAL(FB), DIMENSION(3) :: calc_normal
-      REAL(FB), DIMENSION(3) :: d1, d2
-      d1 = vec2 - vec1
-      d2 = vec3 - vec1
-      calc_normal(1) = d1(2) * d2(3) - d1(3) * d2(2)
-      calc_normal(2) = d1(3) * d2(1) - d1(1) * d2(3)
-      calc_normal(3) = d1(1) * d2(2) - d1(2) * d2(1)
-      calc_normal = calc_normal / norm(calc_normal)
-   END FUNCTION calc_normal
-
-   FUNCTION norm(vec)
+      REAL(FB), DIMENSION(3), INTENT(IN) :: VEC1, VEC2, VEC3
+      REAL(FB), DIMENSION(3) :: CALC_NORMAL
+      REAL(FB), DIMENSION(3) :: D1, D2
+      D1 = VEC2 - VEC1
+      D2 = VEC3 - VEC1
+      CALC_NORMAL(1) = D1(2) * D2(3) - D1(3) * D2(2)
+      CALC_NORMAL(2) = D1(3) * D2(1) - D1(1) * D2(3)
+      CALC_NORMAL(3) = D1(1) * D2(2) - D1(2) * D2(1)
+      CALC_NORMAL = CALC_NORMAL / NORM(CALC_NORMAL)
+   END FUNCTION CALC_NORMAL
+
+   FUNCTION NORM(VEC)
       IMPLICIT NONE
-      REAL(FB), DIMENSION(3), INTENT(IN) :: vec
-      REAL(FB) :: norm
-      norm = sqrt(vec(1)**2 + vec(2)**2 + vec(3)**2)
-   END FUNCTION norm
+      REAL(FB), DIMENSION(3), INTENT(IN) :: VEC
+      REAL(FB) :: NORM
+      NORM = SQRT(VEC(1)**2 + VEC(2)**2 + VEC(3)**2)
+   END FUNCTION NORM
 
 END SUBROUTINE WRITE_STL_FILE
 

From 19f13b804313c8fb9c12409437c3874768a0db6c Mon Sep 17 00:00:00 2001
From: johodges <johodges@vt.edu>
Date: Wed, 20 Dec 2023 16:45:08 -0500
Subject: [PATCH 06/31] add export_to_vtk.py to utilities

---
 Utilities/Python/scripts/export_to_vtk.py | 134 ++++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 Utilities/Python/scripts/export_to_vtk.py

diff --git a/Utilities/Python/scripts/export_to_vtk.py b/Utilities/Python/scripts/export_to_vtk.py
new file mode 100644
index 00000000000..4091097a093
--- /dev/null
+++ b/Utilities/Python/scripts/export_to_vtk.py
@@ -0,0 +1,134 @@
+import pyfdstools as fds
+import os, glob, sys, argparse
+import numpy as np
+
+if __name__ == '__main__':
+    
+    args = sys.argv
+    systemPath = os.path.dirname(os.path.abspath(__file__))
+    
+    filename = 'export_to_vtk.py'
+    
+    availableArguments = "--help\n"
+    availableArguments = availableArguments + "--all Outputs all FDS outputs to VTK\n"
+    availableArguments = availableArguments + "--binary Selects whether VTK files are ASCIi or Binary\n"
+    availableArguments = availableArguments + "--bnde Exports BNDE files to VTK, default False\n"
+    availableArguments = availableArguments + "--bndf Exports BNDF files to VTK, default False\n"
+    availableArguments = availableArguments + "--chid CHID of the FDS case, defaults to basename of the first .fds file in dir\n"
+    availableArguments = availableArguments + "--clean Deletes VTK and related files from dir prior to run\n"
+    availableArguments = availableArguments + "--indir Directory of the FDS output files, defaults to current working directory\n"
+    availableArguments = availableArguments + "--outdir Directory of the VTK files, defaults to current working directory\n"
+    availableArguments = availableArguments + '--times Establishes the time interval to export data [start time, end time, NFRAMES]\n'
+    availableArguments = availableArguments + "--prt5 Exports PRT5 files to VTK, default False\n"
+    availableArguments = availableArguments + "--sl2d Exports SL2D files to VTK, default False\n"
+    availableArguments = availableArguments + "--sl3d Exports SL3D files to VTK, default False\n"
+    availableArguments = availableArguments + "--s3d Exports S3D files to VTK, default False\n"
+    availableArguments = availableArguments + "--stl Generates STL file based on geometry, default True"
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('call')
+    parser.add_argument('--all', action='store_true', default=False, help='Outputs all FDS outputs to VTK, default False')
+    parser.add_argument('--binary', action='store_true', default=False, help='Selects whether VTK files are ASCII or Binary, default ASCII')
+    parser.add_argument('--bnde', action='store_true', default=False, help='Exports BNDE files to VTK, default False')
+    parser.add_argument('--bndf', action='store_true', default=False, help='Exports BNDF files to VTK, default False')
+    parser.add_argument('--chid', nargs=1, default=[], help='CHID of the FDS case, defaults to basename of the first .fds file in dir')
+    parser.add_argument('--clean', action='store_true', help='Deletes VTK and related files from dir prior to run')
+    parser.add_argument('--indir', nargs=1, default=[], help='Directory of the FDS output files, defaults to current working directory')
+    parser.add_argument('--outdir', nargs=1, default=[], help='Directory of the VTK output files, defaults to current working directory')
+    parser.add_argument('--prt5', action='store_true', default=False, help='Exports PRT5 files to VTK, default False')
+    parser.add_argument('--sl2d', action='store_true', default=False, help='Exports SL2D files to VTK, default False')
+    parser.add_argument('--sl3d', action='store_true', default=False, help='Exports SL3D files to VTK, default False')
+    parser.add_argument('--s3d', action='store_true', default=False, help='Exports S3D files to VTK, default False')
+    parser.add_argument('--stl', action='store_true', default=False, help='Disables export of STL file, default True')
+    parser.add_argument('--times', nargs=3, default=[], help='Establishes the time interval to export data [start time, end time, NFRAMES]')
+    #parser.add_argument('--help', action='store_true', default=False)
+    
+    if len(args) == 1:
+        sys.exit("Available arguments\n%s"%(availableArguments))
+    
+    cmdargs = parser.parse_args(args)
+    
+    if len(cmdargs.indir) == 0:
+        print("Warning, no input directory was provided, assuming the script directory.")
+        rdir = os.getcwd() + os.sep
+    else:
+        if os.path.isabs(cmdargs.indir[0]):
+            rdir = cmdargs.indir[0] + os.sep
+        else:
+            rdir = os.path.abspath(cmdargs.indir[0]) + os.sep
+    if len(cmdargs.outdir) == 0:
+        print("Warning, no input directory was provided, assuming the script directory.")
+        odir = os.getcwd() + os.sep
+    else:
+        if os.spath.isabs(cmdargs.outdir[0]):
+            odir = cmdargs.outdir[0] + os.sep
+        else:
+            odir = os.path.abspath(cmd.args.outdir[0]) + os.sep
+    
+    if len(cmdargs.chid) == 0:
+        print("Warning, no chid was provided, assuming the namespace of the fds file.")
+        fdsFiles = fds.getFileList(rdir, '', 'fds')
+        if len(fdsFiles) == 0:
+            sys.exit('No fds files found in %s.'%(rdir))
+        if len(fdsFiles) > 1:
+            print("Warning, multiple fds files found, assuming %s is correct."%(fdsFiles[0]))
+        chid = os.path.basename(fdsFiles[0]).replace('.fds','')
+        print('CHID = %s'%(chid))
+    else:
+        chid = cmdargs.chid[0]
+    
+    if cmdargs.clean:
+        for f in glob.glob(odir + '*.vtr'):
+            os.remove(f)
+        for f in glob.glob(odir + '*.pvtr'):
+            os.remove(f)
+        for f in glob.glob(odir + '*.vti'):
+            os.remove(f)
+        for f in glob.glob(odir + '*.pvti'):
+            os.remove(f)
+        for f in glob.glob(odir + '*.vtp'):
+            os.remove(f)
+        for f in glob.glob(odir + '*.pvtp'):
+            os.remove(f)
+    
+    if cmdargs.all:
+        cmdargs.sl2d = True
+        cmdargs.sl3d = True
+        cmdargs.s3d = True
+        cmdargs.bndf = True
+        cmdargs.bnde = True
+        cmdargs.prt5 = True
+    
+    if len(cmdargs.times) == 0:
+        outTimes = None
+    else:
+        outTimes = np.linspace(float(cmdargs.times[0]), float(cmdargs.times[1]), int(cmdargs.times[2]))
+    
+    if not cmdargs.stl:
+        fds.obstToStl(rdir, chid)
+
+    if cmdargs.sl2d:
+        print("Converting SL2D to VTK...")
+        fds.exportSl2dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+    
+    if cmdargs.sl3d:
+        print("Converting SL3D to VTK...")
+        fds.exportSl3dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+        
+    if cmdargs.s3d:
+        print("Converting S3D to VTK...")
+        fds.exportS3dDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+    
+    if cmdargs.bndf:
+        print("Converting BNDF to VTK...")
+        fds.exportBndfDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+    
+    if cmdargs.bnde:
+        print("Converting BNDE to VTK...")
+        fds.exportBndeDataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+        
+    if cmdargs.prt5:
+        print("Converting PRT5 to VTK...")
+        fds.exportPrt5DataToVtk(chid, rdir, outtimes=outTimes, binary=cmdargs.binary)
+        
+

From d3ae14b1a3eaa94cdeb59f978c32570241750169 Mon Sep 17 00:00:00 2001
From: johodges <johodges@vt.edu>
Date: Fri, 22 Dec 2023 16:49:34 -0500
Subject: [PATCH 07/31] small fix in cmdargs

---
 Utilities/Python/scripts/export_to_vtk.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Utilities/Python/scripts/export_to_vtk.py b/Utilities/Python/scripts/export_to_vtk.py
index 4091097a093..dbe519532af 100644
--- a/Utilities/Python/scripts/export_to_vtk.py
+++ b/Utilities/Python/scripts/export_to_vtk.py
@@ -63,7 +63,7 @@
         if os.spath.isabs(cmdargs.outdir[0]):
             odir = cmdargs.outdir[0] + os.sep
         else:
-            odir = os.path.abspath(cmd.args.outdir[0]) + os.sep
+            odir = os.path.abspath(cmdargs.outdir[0]) + os.sep
     
     if len(cmdargs.chid) == 0:
         print("Warning, no chid was provided, assuming the namespace of the fds file.")

From 5f3b2f8f4133096118a311c3695eb248ec27d4b9 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 23 Dec 2023 18:53:38 -0500
Subject: [PATCH 08/31] add vtk write for 3d slice

---
 Source/cons.f90 |  7 ++--
 Source/dump.f90 | 87 ++++++++++++++++++++++++++++++++++++++++++++-----
 Source/read.f90 |  8 +++--
 3 files changed, 88 insertions(+), 14 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 811c1e573c1..92eccb74528 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -760,10 +760,11 @@ MODULE OUTPUT_CLOCKS
 INTEGER :: RAMP_SPEC_INDEX=0  !< Ramp index for species file time series
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,&
                                        ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,&
-                                       SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK
+                                       SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK
 INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,&
                                       HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,&
-                                      RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER
+                                      RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,&
+                                      VTK_COUNTER
 REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB
 REAL(EB) :: MMS_TIMER=1.E10_EB
 REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,&
@@ -773,7 +774,7 @@ MODULE OUTPUT_CLOCKS
             DT_HVAC_SPECIFIED =-1._EB,DT_MASS_SPECIFIED   =-1._EB,DT_PROF_SPECIFIED=-1._EB,DT_CTRL_SPECIFIED=-1._EB,&
             DT_FLUSH_SPECIFIED=-1._EB,DT_SL3D_SPECIFIED   =-1._EB,DT_GEOM_SPECIFIED=-1._EB,DT_CPU_SPECIFIED =-1._EB,&
             DT_RADF_SPECIFIED =-1._EB,DT_SMOKE3D_SPECIFIED=-1._EB,DT_UVW_SPECIFIED =-1._EB,DT_TMP_SPECIFIED =-1._EB,&
-            DT_SPEC_SPECIFIED =-1._EB
+            DT_SPEC_SPECIFIED =-1._EB,DT_VTK_SPECIFIED    =-1._EB
 
 END MODULE OUTPUT_CLOCKS
 
diff --git a/Source/dump.f90 b/Source/dump.f90
index 75529be1ef2..3ec74367235 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,6 +19,8 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
+USE PENF
+USE VTK_FORTRAN, ONLY : VTK_FILE
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
@@ -129,6 +131,14 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
+IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
+   CALL DUMP_SLCF(T,DT,NM,3)
+   DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1)
+      VTK_COUNTER(NM) = VTK_COUNTER(NM) + 1
+      IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT
+   ENDDO
+ENDIF
+
 IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN
    CALL DUMP_BNDF(T,DT,NM)
    DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1)
@@ -5762,7 +5772,7 @@ END SUBROUTINE GET_GASCUTFACE_SCALAR_SLICE
 !> \param T Current simulation time (s)
 !> \param DT Current time step size (s)
 !> \param NM Mesh number
-!> \param IFRMT Slice (IFRMT=0) or Plot3D (IFRMT=1) or 3D slice (IFRMT=2)
+!> \param IFRMT Slice (IFRMT=0) or Plot3D (IFRMT=1) or 3D slice (IFRMT=2) or VTK slice (IFRMT=3)
 
 SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
@@ -5780,7 +5790,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 INTEGER :: KTS,NTSL
 REAL(EB), POINTER, DIMENSION(:,:,:) :: B,S,QUANTITY
 REAL(FB) :: ZERO,STIME
-LOGICAL :: PLOT3D,SLCF3D
+LOGICAL :: PLOT3D,SLCF3D,VTK3D
 LOGICAL :: AGL_TERRAIN_SLICE,CC_CELL_CENTERED,CC_INTERP2FACES
 REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE
 INTEGER :: NX, NY, NZ
@@ -5788,15 +5798,19 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
 REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX
 INTEGER :: IERROR
+TYPE(VTK_FILE)     :: A_VTK_FILE                             ! A VTK file.
+CHARACTER(80) :: VTK_FILE_NAME
+INTEGER(IB4)  :: VTK_ERROR=0_IB4                    !< IO Error status.
 
 ! Return if there are no slices to process and this is not a Plot3D dump
 
 DRY=.FALSE.
 
 SELECT CASE(IFRMT)
-   CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE.
-   CASE(1) ; PLOT3D=.TRUE.  ; SLCF3D=.FALSE.
-   CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE.
+   CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE.
+   CASE(1) ; PLOT3D=.TRUE.  ; SLCF3D=.FALSE. ; VTK3D=.FALSE.
+   CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.FALSE.
+   CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.TRUE.
 END SELECT
 
 IF (MESHES(NM)%N_SLCF==0 .AND. .NOT.PLOT3D) RETURN
@@ -5836,10 +5850,12 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 ! If sprinkler diagnostic on, pre-compute various PARTICLE flux output
 
-IF (.NOT.PLOT3D) THEN
+IF (.NOT.PLOT3D .AND. .NOT.VTK3D)  THEN
    IF (SLCF_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM)
-ELSE
+ELSEIF (.NOT.VTK3D) THEN
    IF (PL3D_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM)
+ELSE
+   IF (SLCF_PARTICLE_FLUX) CALL COMPUTE_PARTICLE_FLUXES(NM) ! TODO Not sure what we need for VTK here
 ENDIF
 
 ! Determine slice or Plot3D indicies
@@ -5886,6 +5902,25 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 NTSL = 0
 
+IF (VTK3D) THEN
+   SL => SLICE(IQ)
+   STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+   WRITE(VTK_FILE_NAME,  '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr'
+   IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
+      WRITE(*,*) "HELLO WORLD"
+      VTK_ERROR = A_VTK_FILE%initialize(format='ascii', filename=VTK_FILE_NAME, &
+                                    mesh_topology='RectilinearGrid', &
+                                    nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='open')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=0._FB, data_name='TIME')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=1_IB16, data_name='CYCLE')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='close')
+      ! write one piece
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_piece(nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) ! Piece Extent
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_geo(x=x, y=y, z=z) ! Piece coordinates
+   ENDIF
+ENDIF
+
 QUANTITY_LOOP: DO IQ=1,NQT
 
    IF (PLOT3D) THEN
@@ -6035,7 +6070,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
    ! Dump out the slice file to a .sf file
 
-   IF (.NOT.PLOT3D) THEN
+   IF (.NOT.PLOT3D .and. .NOT.VTK3D) THEN
       SL => SLICE(IQ)
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
@@ -6189,6 +6224,42 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       ENDIF
    ENDIF
 
+
+
+   ! Dump out the slice file to a .vtk file
+
+   IF (VTK3D) THEN
+      SL => SLICE(IQ)
+      IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
+         IF (NX*NY*NZ>0) THEN
+            ALLOCATE(QQ_PACK(NX*NY*NZ))
+
+            DO K = K1, K2
+               KFACT = (K-K1)
+               DO J = J1, J2
+                  JFACT = (J-J1)*NZ
+                  DO I = I1, I2
+                     IFACT = (I - I1)*NY*NZ
+                     QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1)
+                  ENDDO
+               ENDDO
+            ENDDO
+            ! write one quantity
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='open')
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME='cell_value', X=QQ_PACK)
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='close')
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+            DEALLOCATE(QQ_PACK)
+         ENDIF
+      ENDIF
+   ENDIF
+
+IF (VTK3D) THEN
+   ! finish after writing all pieces
+   WRITE(*,*) "HELLO WORLD 2"
+   VTK_ERROR = A_VTK_FILE%FINALIZE()
+ENDIF
+
 ENDDO QUANTITY_LOOP
 
 ! Write out the PLOT3D ``q'' file
diff --git a/Source/read.f90 b/Source/read.f90
index d7e3b13d103..211a8b8c44e 100644
--- a/Source/read.f90
+++ b/Source/read.f90
@@ -2252,13 +2252,13 @@ SUBROUTINE READ_DUMP
 NAMELIST /DUMP/ CFL_FILE,CLIP_RESTART_FILES,COLUMN_DUMP_LIMIT,CTRL_COLUMN_LIMIT,DEVC_COLUMN_LIMIT,&
                 DIAGNOSTICS_INTERVAL,&
                 DT_BNDF,DT_CPU,DT_CTRL,DT_DEVC,DT_FLUSH,DT_HRR,DT_HVAC,DT_ISOF,DT_MASS,DT_PART,DT_PL3D,DT_PROF,&
-                DT_RADF,DT_RESTART,DT_SL3D,DT_SLCF,DT_SMOKE3D,DT_UVW,DT_TMP,DT_SPEC,&
+                DT_RADF,DT_RESTART,DT_SL3D,DT_SLCF,DT_SMOKE3D,DT_UVW,DT_TMP,DT_SPEC,DT_VTK,&
                 FLUSH_FILE_BUFFERS,GET_CUTCELLS_VERBOSE,HRR_GAS_ONLY,MASS_FILE,MAXIMUM_PARTICLES,MMS_TIMER,&
                 NFRAMES,PLOT3D_PART_ID,PLOT3D_QUANTITY,PLOT3D_SPEC_ID,PLOT3D_VELO_INDEX,&
                 RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,&
                 RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,&
-                RAMP_SPEC,RAMP_TMP,RAMP_UVW,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,SUPPRESS_DIAGNOSTICS,&
-                TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL
+                RAMP_SPEC,RAMP_TMP,RAMP_UVW,RAMP_VTK,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,&
+                SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL
 
 ! Set defaults
 
@@ -2302,6 +2302,7 @@ SUBROUTINE READ_DUMP
 DT_SL3D      =  (T_END-T_BEGIN)/5._EB  ; RAMP_SL3D    = 'null' ; DT_SL3D_SPECIFIED    = DT_SL3D
 DT_SMOKE3D   = -1._EB                  ; RAMP_SMOKE3D = 'null' ; DT_SMOKE3D_SPECIFIED = DT_SMOKE3D
 DT_UVW       =  HUGE(EB)               ; RAMP_UVW     = 'null' ; DT_UVW_SPECIFIED     = DT_UVW
+DT_VTK       =  HUGE(EB)               ; RAMP_VTK     = 'null' ; DT_VTK_SPECIFIED     = DT_VTK
 DT_TMP       =  HUGE(EB)               ; RAMP_TMP     = 'null' ; DT_TMP_SPECIFIED     = DT_TMP
 DT_SPEC      =  HUGE(EB)               ; RAMP_SPEC    = 'null' ; DT_SPEC_SPECIFIED    = DT_SPEC
 DIAGNOSTICS_INTERVAL = 100
@@ -2340,6 +2341,7 @@ SUBROUTINE READ_DUMP
 IF (DT_UVW_SPECIFIED    /= DT_UVW)     THEN ; DT_UVW_SPECIFIED    = DT_UVW     ; ELSE ; DT_UVW_SPECIFIED    = -1._EB ; ENDIF
 IF (DT_TMP_SPECIFIED    /= DT_TMP)     THEN ; DT_TMP_SPECIFIED    = DT_TMP     ; ELSE ; DT_TMP_SPECIFIED    = -1._EB ; ENDIF
 IF (DT_SPEC_SPECIFIED   /= DT_SPEC)    THEN ; DT_SPEC_SPECIFIED   = DT_SPEC    ; ELSE ; DT_SPEC_SPECIFIED   = -1._EB ; ENDIF
+IF (DT_VTK_SPECIFIED    /= DT_VTK)     THEN ; DT_VTK_SPECIFIED    = DT_PL3D    ; ELSE ; DT_VTK_SPECIFIED   = -1._EB ; ENDIF
 
 ! Timing RAMPs
 

From 863d9000953163acf0cd742fe4b82c21da353bc2 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 23 Dec 2023 19:00:03 -0500
Subject: [PATCH 09/31] add parameters for VTK output

---
 Source/cons.f90 |  3 ++-
 Source/dump.f90 | 18 +++++++++---------
 Source/read.f90 |  2 +-
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 92eccb74528..743ac80929c 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -758,6 +758,7 @@ MODULE OUTPUT_CLOCKS
 INTEGER :: RAMP_UVW_INDEX =0  !< Ramp index for velocity file time series
 INTEGER :: RAMP_TMP_INDEX =0  !< Ramp index for temperature file time series
 INTEGER :: RAMP_SPEC_INDEX=0  !< Ramp index for species file time series
+INTEGER :: RAMP_VTK_INDEX=0   !< Ramp index for vtk file time series
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,&
                                        ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,&
                                        SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK
@@ -768,7 +769,7 @@ MODULE OUTPUT_CLOCKS
 REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB
 REAL(EB) :: MMS_TIMER=1.E10_EB
 REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,&
-            DT_FLUSH,DT_SL3D,DT_GEOM,DT_CPU,DT_RADF,DT_SMOKE3D,DT_UVW ,DT_TMP,DT_SPEC
+            DT_FLUSH,DT_SL3D,DT_GEOM,DT_CPU,DT_RADF,DT_SMOKE3D,DT_UVW ,DT_TMP,DT_SPEC,DT_VTK
 REAL(EB) :: DT_SLCF_SPECIFIED =-1._EB,DT_BNDF_SPECIFIED   =-1._EB,DT_DEVC_SPECIFIED=-1._EB,DT_PL3D_SPECIFIED=-1._EB,&
             DT_PART_SPECIFIED =-1._EB,DT_RESTART_SPECIFIED=-1._EB,DT_ISOF_SPECIFIED=-1._EB,DT_HRR_SPECIFIED =-1._EB,&
             DT_HVAC_SPECIFIED =-1._EB,DT_MASS_SPECIFIED   =-1._EB,DT_PROF_SPECIFIED=-1._EB,DT_CTRL_SPECIFIED=-1._EB,&
diff --git a/Source/dump.f90 b/Source/dump.f90
index 3ec74367235..4418664199f 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -5908,16 +5908,16 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
    WRITE(VTK_FILE_NAME,  '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr'
    IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
       WRITE(*,*) "HELLO WORLD"
-      VTK_ERROR = A_VTK_FILE%initialize(format='ascii', filename=VTK_FILE_NAME, &
-                                    mesh_topology='RectilinearGrid', &
-                                    nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2)
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='open')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=0._FB, data_name='TIME')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(x=1_IB16, data_name='CYCLE')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_fielddata(action='close')
+      VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=VTK_FILE_NAME, &
+                                    MESH_TOPOLOGY='RectilinearGrid', &
+                                    NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='open')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=0._FB, DATA_NAME='TIME')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=1_IB16, DATA_NAME='CYCLE')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='close')
       ! write one piece
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_piece(nx1=I1, nx2=I2, ny1=J1, ny2=J2, nz1=K1, nz2=K2) ! Piece Extent
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%write_geo(x=x, y=y, z=z) ! Piece coordinates
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=X, Y=Y, Z=Z) ! Piece coordinates
    ENDIF
 ENDIF
 
diff --git a/Source/read.f90 b/Source/read.f90
index 211a8b8c44e..82e24a77416 100644
--- a/Source/read.f90
+++ b/Source/read.f90
@@ -2248,7 +2248,7 @@ SUBROUTINE READ_DUMP
 INTEGER :: N,SIG_FIGS,SIG_FIGS_EXP
 CHARACTER(LABEL_LENGTH) :: RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_GEOM,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,&
                            RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,RAMP_UVW,&
-                           RAMP_TMP,RAMP_SPEC
+                           RAMP_TMP,RAMP_SPEC,RAMP_VTK
 NAMELIST /DUMP/ CFL_FILE,CLIP_RESTART_FILES,COLUMN_DUMP_LIMIT,CTRL_COLUMN_LIMIT,DEVC_COLUMN_LIMIT,&
                 DIAGNOSTICS_INTERVAL,&
                 DT_BNDF,DT_CPU,DT_CTRL,DT_DEVC,DT_FLUSH,DT_HRR,DT_HVAC,DT_ISOF,DT_MASS,DT_PART,DT_PL3D,DT_PROF,&

From 9956c1c62d429f1a2ab88deb544a6d420ce1e486 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 26 Dec 2023 10:01:23 -0500
Subject: [PATCH 10/31] add initialization of VTK clocks

---
 Source/func.f90 | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Source/func.f90 b/Source/func.f90
index 0df81bd4392..bd92f564667 100644
--- a/Source/func.f90
+++ b/Source/func.f90
@@ -481,6 +481,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T)
 CALL SET_OUTPUT_CLOCK(DT_UVW    ,RAMP_UVW_INDEX , UVW_CLOCK, UVW_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_TMP    ,RAMP_TMP_INDEX , TMP_CLOCK, TMP_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_SPEC   ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. )
+CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_VTK_INDEX,  VTK_CLOCK, VTK_COUNTER,.TRUE. ,.TRUE. )
 
 ! Special cases
 

From c0b3fde9da58d3ca6ba99cb035730cdc8661248b Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 26 Dec 2023 16:11:42 -0500
Subject: [PATCH 11/31] fix for VTK with 3-d slices in multiple meshes

---
 Source/cons.f90 |  3 +-
 Source/dump.f90 | 77 ++++++++++++++++++++++++++++---------------------
 2 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 743ac80929c..93909e7a7f6 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -545,10 +545,11 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(80)                              :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT
 CHARACTER(80)                              :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART
-CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
+CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM, FN_VTK
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, &
                                               FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF
 
+
 CHARACTER(9) :: FMT_R
 LOGICAL :: OUT_FILE_OPENED=.FALSE.
 
diff --git a/Source/dump.f90 b/Source/dump.f90
index 4418664199f..f36663b77a1 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -336,6 +336,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(LU_XYZ(NMESHES))
 ALLOCATE(FN_PL3D(2*NMESHES))
 ALLOCATE(LU_PL3D(2*NMESHES))
+ALLOCATE(FN_VTK(NMESHES))
 
 ALLOCATE(FN_ISOF(N_ISOF,NMESHES))
 ALLOCATE(LU_ISOF(N_ISOF,NMESHES))
@@ -5799,8 +5800,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX
 INTEGER :: IERROR
 TYPE(VTK_FILE)     :: A_VTK_FILE                             ! A VTK file.
-CHARACTER(80) :: VTK_FILE_NAME
 INTEGER(IB4)  :: VTK_ERROR=0_IB4                    !< IO Error status.
+LOGICAL :: VTK_INITIALIZED
 
 ! Return if there are no slices to process and this is not a Plot3D dump
 
@@ -5810,7 +5811,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
    CASE(0) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.FALSE.
    CASE(1) ; PLOT3D=.TRUE.  ; SLCF3D=.FALSE. ; VTK3D=.FALSE.
    CASE(2) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.FALSE.
-   CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.FALSE. ; VTK3D=.TRUE.
+   CASE(3) ; PLOT3D=.FALSE. ; SLCF3D=.TRUE. ; VTK3D=.TRUE.
 END SELECT
 
 IF (MESHES(NM)%N_SLCF==0 .AND. .NOT.PLOT3D) RETURN
@@ -5901,25 +5902,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 ENDIF
 
 NTSL = 0
-
-IF (VTK3D) THEN
-   SL => SLICE(IQ)
-   STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
-   WRITE(VTK_FILE_NAME,  '(A,A,I0,A,I0,A)') TRIM(CHID),'_',NM,'_',STIME,'.vtr'
-   IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-      WRITE(*,*) "HELLO WORLD"
-      VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=VTK_FILE_NAME, &
-                                    MESH_TOPOLOGY='RectilinearGrid', &
-                                    NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2)
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='open')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=0._FB, DATA_NAME='TIME')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(X=1_IB16, DATA_NAME='CYCLE')
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_FIELDDATA(ACTION='close')
-      ! write one piece
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent
-      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=X, Y=Y, Z=Z) ! Piece coordinates
-   ENDIF
-ENDIF
+VTK_INITIALIZED=.FALSE.
 
 QUANTITY_LOOP: DO IQ=1,NQT
 
@@ -5964,6 +5947,28 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       IF ((I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) .AND.      SLCF3D) CYCLE QUANTITY_LOOP
    ENDIF
 
+   IF (VTK3D .AND. .NOT.VTK_INITIALIZED) THEN
+      SL => SLICE(IQ)
+      STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+      TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+      ITM  = INT(TT)
+      ITM1 = NINT(ABS(TT-ITM)*100)
+      IF (ITM1==100) THEN
+         ITM = ITM+1
+         ITM1 = 0
+      ENDIF
+      IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), &
+                                       MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., &
+                                       NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2)
+         ! write one piece
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=MESHES(NM)%XPLT, Y=MESHES(NM)%YPLT, Z=MESHES(NM)%ZPLT) ! Piece coordinates
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='open')
+      ENDIF
+      VTK_INITIALIZED=.TRUE.
+   ENDIF
+
    ! Determine what cells need to be evaluated to form cell-corner averages
 
    II1 = I1
@@ -6230,25 +6235,30 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
    IF (VTK3D) THEN
       SL => SLICE(IQ)
+      I1=SL%I1
+      I2=SL%I2
+      J1=SL%J1
+      J2=SL%J2
+      K1=SL%K1
+      K2=SL%K2
+      NX = I2 + 1 - I1
+      NY = J2 + 1 - J1
+      NZ = K2 + 1 - K1
+      WRITE(*,*) "STARTING TO PACK", SL%SLICETYPE, NX, NY, NZ, I1, I2, J1, J2, K1, K2
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          IF (NX*NY*NZ>0) THEN
             ALLOCATE(QQ_PACK(NX*NY*NZ))
-
-            DO K = K1, K2
-               KFACT = (K-K1)
+            DO I = I1, I2
+               IFACT = (I-I1)
                DO J = J1, J2
-                  JFACT = (J-J1)*NZ
-                  DO I = I1, I2
-                     IFACT = (I - I1)*NY*NZ
+                  JFACT = (J-J1)*NX
+                  DO K = K1, K2
+                     KFACT = (K - K1)*NY*NX
                      QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1)
                   ENDDO
                ENDDO
             ENDDO
-            ! write one quantity
-            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='open')
-            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME='cell_value', X=QQ_PACK)
-            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='cell', ACTION='close')
-            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
             DEALLOCATE(QQ_PACK)
          ENDIF
       ENDIF
@@ -6256,7 +6266,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 IF (VTK3D) THEN
    ! finish after writing all pieces
-   WRITE(*,*) "HELLO WORLD 2"
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='close')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
    VTK_ERROR = A_VTK_FILE%FINALIZE()
 ENDIF
 

From b0b4bdcd68cabba3f276b6d5c4a45273719c3e66 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 26 Dec 2023 16:19:51 -0500
Subject: [PATCH 12/31] clean-up debug writing lines

---
 Source/dump.f90 | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index f36663b77a1..0f719dbd308 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -5957,6 +5957,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
+      WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtr'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), &
                                        MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., &
@@ -6244,10 +6245,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       NX = I2 + 1 - I1
       NY = J2 + 1 - J1
       NZ = K2 + 1 - K1
-      WRITE(*,*) "STARTING TO PACK", SL%SLICETYPE, NX, NY, NZ, I1, I2, J1, J2, K1, K2
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          IF (NX*NY*NZ>0) THEN
-            ALLOCATE(QQ_PACK(NX*NY*NZ))
+            ALLOCATE(QQ_PACK(NX*NY*NZ)
+            
             DO I = I1, I2
                IFACT = (I-I1)
                DO J = J1, J2
@@ -6258,6 +6259,8 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
                   ENDDO
                ENDDO
             ENDDO
+            
+            ! write one quantity
             VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
             DEALLOCATE(QQ_PACK)
          ENDIF

From 300d38ce5059f41d14557a6fd513f7e0ecddab23 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 26 Dec 2023 16:21:04 -0500
Subject: [PATCH 13/31] fix missing parethensis

---
 Source/dump.f90 | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 0f719dbd308..959e94748cc 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -6247,8 +6247,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       NZ = K2 + 1 - K1
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          IF (NX*NY*NZ>0) THEN
-            ALLOCATE(QQ_PACK(NX*NY*NZ)
-            
+            ALLOCATE(QQ_PACK(NX*NY*NZ))
             DO I = I1, I2
                IFACT = (I-I1)
                DO J = J1, J2

From 7b7d1597f667ff18690db38978d789bfd40c0d72 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 28 Dec 2023 11:29:09 -0500
Subject: [PATCH 14/31] swap to vtu format for 3d slices

---
 Source/dump.f90 | 88 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 77 insertions(+), 11 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 959e94748cc..924b513c5a5 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,8 +19,10 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
+#ifdef WITH_VTK
 USE PENF
 USE VTK_FORTRAN, ONLY : VTK_FILE
+#endif /* WITH_VTK */
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
@@ -5794,9 +5796,11 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 LOGICAL :: PLOT3D,SLCF3D,VTK3D
 LOGICAL :: AGL_TERRAIN_SLICE,CC_CELL_CENTERED,CC_INTERP2FACES
 REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE
-INTEGER :: NX, NY, NZ
+INTEGER :: NX, NY, NZ, NC, NP
 INTEGER :: IFACT, JFACT, KFACT
-REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS
+INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE
 REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX
 INTEGER :: IERROR
 TYPE(VTK_FILE)     :: A_VTK_FILE                             ! A VTK file.
@@ -5957,15 +5961,77 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
-      WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtr'
+      WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_VTK(NM), &
-                                       MESH_TOPOLOGY='RectilinearGrid', is_volatile=.FALSE., &
-                                       NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2)
-         ! write one piece
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NX1=I1, NX2=I2, NY1=J1, NY2=J2, NZ1=K1, NZ2=K2) ! Piece Extent
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(X=MESHES(NM)%XPLT, Y=MESHES(NM)%YPLT, Z=MESHES(NM)%ZPLT) ! Piece coordinates
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='open')
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ! do not change capitalization on mesh topology
+         
+         I1=SL%I1
+         I2=SL%I2
+         J1=SL%J1
+         J2=SL%J2
+         K1=SL%K1
+         K2=SL%K2
+         NX = I2 + 1 - I1
+         NY = J2 + 1 - J1
+         NZ = K2 + 1 - K1
+         NP = NX*NY*NZ
+         NC = (NX-1)*(NY-1)*(NZ-1)
+         
+         ! Fill point data
+         ALLOCATE(X_PTS(NP))
+         ALLOCATE(Y_PTS(NP))
+         ALLOCATE(Z_PTS(NP))
+         IFACT = 1
+         DO K = 0, NZ-1
+            DO J = 0, NY-1
+               DO I = 0, NX-1
+                  X_PTS(IFACT)=MESHES(NM)%X(I)
+                  Y_PTS(IFACT)=MESHES(NM)%Y(J)
+                  Z_PTS(IFACT)=MESHES(NM)%Z(K)
+                  IFACT = IFACT + 1
+               ENDDO
+            ENDDO
+         ENDDO
+         
+         ! Fill cell data
+         ALLOCATE(CONNECT(NC*8))
+         DO I = 1, NX-1
+            IFACT = (I-1)
+            DO J = 1, NY-1
+               JFACT = (J-1)*(NX-1)
+               DO K = 1, NZ-1
+                  KFACT = (K - 1)*(NY-1)*(NX-1)
+                  CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1
+                  CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I
+                  CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1
+                  CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I
+                  CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1
+                  CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I
+                  CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1
+                  CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I
+               ENDDO
+            ENDDO
+         ENDDO
+         
+         ALLOCATE(OFFSETS(NC))
+         ALLOCATE(CELL_TYPE(NC))
+         
+         DO I=1,NC
+            OFFSETS(I) = (I)*8_IB4
+            CELL_TYPE(I) = 11_IB4
+         ENDDO
+         
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN')
+         
+         DEALLOCATE(OFFSETS)
+         DEALLOCATE(CELL_TYPE)
+         DEALLOCATE(CONNECT)
+         DEALLOCATE(X_PTS)
+         DEALLOCATE(Y_PTS)
+         DEALLOCATE(Z_PTS)
       ENDIF
       VTK_INITIALIZED=.TRUE.
    ENDIF
@@ -6268,7 +6334,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 IF (VTK3D) THEN
    ! finish after writing all pieces
-   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='close')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE')
    VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
    VTK_ERROR = A_VTK_FILE%FINALIZE()
 ENDIF

From 2678b8bfff656527ec4d4a5e0e4d69654a889df4 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 28 Dec 2023 12:54:03 -0500
Subject: [PATCH 15/31] add VTK_BINARY logical flag to read

---
 Source/cons.f90 | 1 +
 Source/dump.f90 | 6 +++++-
 Source/read.f90 | 3 ++-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 93909e7a7f6..f20ca5080aa 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -256,6 +256,7 @@ MODULE GLOBAL_CONSTANTS
 LOGICAL :: REACTING_THIN_OBSTRUCTIONS=.FALSE.       !< Thin obstructions that off-gas are present
 LOGICAL :: SMOKE3D_16=.FALSE.                       !< Output 3D smoke values using 16 bit integers
 LOGICAL :: CHECK_BOUNDARY_ONE_D_ARRAYS=.FALSE.      !< Flag that indicates that ONE_D array dimensions need to be checked
+LOGICAL :: VTK_BINARY=.TRUE.                        !< Flag that indicates VTK outputs should be binary or ascii
 
 INTEGER, ALLOCATABLE, DIMENSION(:) :: CHANGE_TIME_STEP_INDEX      !< Flag to indicate if a mesh needs to change time step
 INTEGER, ALLOCATABLE, DIMENSION(:) :: SETUP_PRESSURE_ZONES_INDEX  !< Flag to indicate if a mesh needs to keep searching for ZONEs
diff --git a/Source/dump.f90 b/Source/dump.f90
index 924b513c5a5..af7a5e15841 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -5963,7 +5963,11 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       ENDIF
       WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid') ! do not change capitalization on mesh topology
+         IF (VTK_BINARY) THEN
+            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+         ELSE
+            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ASCII', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+         ENDIF ! do not change capitalization on mesh topology
          
          I1=SL%I1
          I2=SL%I2
diff --git a/Source/read.f90 b/Source/read.f90
index 82e24a77416..d9613e2350d 100644
--- a/Source/read.f90
+++ b/Source/read.f90
@@ -2258,7 +2258,7 @@ SUBROUTINE READ_DUMP
                 RAMP_BNDF,RAMP_CPU,RAMP_CTRL,RAMP_DEVC,RAMP_FLUSH,RAMP_HRR,RAMP_HVAC,RAMP_ISOF,RAMP_MASS,&
                 RAMP_PART,RAMP_PL3D,RAMP_PROF,RAMP_RADF,RAMP_RESTART,RAMP_SLCF,RAMP_SL3D,RAMP_SMOKE3D,&
                 RAMP_SPEC,RAMP_TMP,RAMP_UVW,RAMP_VTK,RENDER_FILE,SIG_FIGS,SIG_FIGS_EXP,SMOKE3D,STATUS_FILES,&
-                SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,WRITE_XYZ,WRITE_STL
+                SUPPRESS_DIAGNOSTICS,TURB_INIT_CLOCK,VELOCITY_ERROR_FILE,VTK_BINARY,WRITE_XYZ,WRITE_STL
 
 ! Set defaults
 
@@ -2277,6 +2277,7 @@ SUBROUTINE READ_DUMP
 RENDER_FILE        = 'null'
 SIG_FIGS           = 8
 SIG_FIGS_EXP       = 3
+VTK_BINARY         = .TRUE.
 IF (NMESHES>32) THEN
    SUPPRESS_DIAGNOSTICS = .TRUE.
 ELSE

From 30fbcd46b64a5a2bc2ad4358982aacd0c9cec03b Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 28 Dec 2023 21:56:45 -0500
Subject: [PATCH 16/31] build with both VTK implementations

---
 Source/cons.f90 |   2 +-
 Source/dump.f90 |  30 +++++++-
 Source/vtk.f90  | 183 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 212 insertions(+), 3 deletions(-)
 create mode 100644 Source/vtk.f90

diff --git a/Source/cons.f90 b/Source/cons.f90
index f20ca5080aa..6f61fa3c0bf 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -535,7 +535,7 @@ MODULE GLOBAL_CONSTANTS
 INTEGER                              :: LU_HISTOGRAM,LU_HVAC
 INTEGER                              :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL
 INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART
-INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM
+INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_VTK
 INTEGER                              :: LU_GEOM_TRAN
 INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LU_SLCF,LU_SLCF_GEOM,LU_BNDF,LU_BNDG,LU_ISOF,LU_ISOF2, &
                                         LU_SMOKE3D,LU_RADF
diff --git a/Source/dump.f90 b/Source/dump.f90
index af7a5e15841..3e01a6c32d4 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -23,6 +23,9 @@ MODULE DUMP
 USE PENF
 USE VTK_FORTRAN, ONLY : VTK_FILE
 #endif /* WITH_VTK */
+USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
+                FINALIZE_VTK
+
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
@@ -133,6 +136,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
+#ifdef WITH_VTK
 IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
    CALL DUMP_SLCF(T,DT,NM,3)
    DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1)
@@ -140,6 +144,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
       IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT
    ENDDO
 ENDIF
+#endif /* WITH_VTK */
 
 IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN
    CALL DUMP_BNDF(T,DT,NM)
@@ -339,6 +344,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(FN_PL3D(2*NMESHES))
 ALLOCATE(LU_PL3D(2*NMESHES))
 ALLOCATE(FN_VTK(NMESHES))
+ALLOCATE(LU_VTK(NMESHES))
 
 ALLOCATE(FN_ISOF(N_ISOF,NMESHES))
 ALLOCATE(LU_ISOF(N_ISOF,NMESHES))
@@ -485,6 +491,10 @@ SUBROUTINE ASSIGN_FILE_NAMES
    WRITE(FN_RESTART(NM),'(A,A,I0,A)') TRIM(RESTART_CHID),'_',NM,'.restart'
    LU_CORE(NM)    = GET_FILE_NUMBER()
    WRITE(FN_CORE(NM),   '(A,A,I0,A)') TRIM(CHID),'_',NM,'.restart'
+   
+   ! VTK Files
+   LU_VTK(NM)              = GET_FILE_NUMBER() ! slice file
+      
 
 ENDDO MESH_LOOP
 
@@ -6030,6 +6040,12 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN')
          
+         WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
+         CALL INITIALIZE_VTK(NM,'UnstructuredGrid')
+         CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii')
+         CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii')
+         WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
+         
          DEALLOCATE(OFFSETS)
          DEALLOCATE(CELL_TYPE)
          DEALLOCATE(CONNECT)
@@ -6331,20 +6347,30 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
             
             ! write one quantity
             VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
+            
+            WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
+            CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
+            
             DEALLOCATE(QQ_PACK)
          ENDIF
       ENDIF
    ENDIF
 
+ENDDO QUANTITY_LOOP
+
 IF (VTK3D) THEN
    ! finish after writing all pieces
    VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE')
    VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
    VTK_ERROR = A_VTK_FILE%FINALIZE()
+   
+   WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
+   CALL FINALIZE_VTK(NM,'UnstructuredGrid')
+   WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
+   
 ENDIF
 
-ENDDO QUANTITY_LOOP
-
 ! Write out the PLOT3D ``q'' file
 
 IF (PLOT3D) THEN
diff --git a/Source/vtk.f90 b/Source/vtk.f90
new file mode 100644
index 00000000000..37329eebe77
--- /dev/null
+++ b/Source/vtk.f90
@@ -0,0 +1,183 @@
+!> \brief Routines for handling vtk output
+
+MODULE VTK
+
+USE MESH_VARIABLES
+USE GLOBAL_CONSTANTS
+
+IMPLICIT NONE (TYPE,EXTERNAL)
+PRIVATE
+
+PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK
+
+CONTAINS
+
+SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY)
+
+INTEGER, INTENT(IN) :: NM
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+
+OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED')
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),'>'
+CLOSE(LU_VTK(NM))
+END SUBROUTINE INITIALIZE_VTK
+
+SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT)
+
+INTEGER, INTENT(IN) :: NM, NC, NP
+REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS
+CHARACTER(LEN=*), INTENT(IN) :: FORMAT
+INTEGER :: I
+
+OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU_VTK(NM),'(A,I0,A,I0,A)',ADVANCE='YES') '    <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">'
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <Points>'
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+   '        <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">'
+
+WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+   DO I=1,NP
+      WRITE(LU_VTK(NM),'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' '
+   ENDDO
+ENDIF
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </Points>'
+CLOSE(LU_VTK(NM))
+
+END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY
+
+SUBROUTINE WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, FORMAT)
+
+INTEGER, INTENT(IN) :: NM
+INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS
+INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE
+CHARACTER(LEN=*), INTENT(IN) :: FORMAT
+INTEGER :: I
+
+! Open cells section
+OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <Cells>'
+
+! Write connectivity
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+   '        <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">'
+
+WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+   DO I=1,SIZE(CONNECT)
+      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CONNECT(I), ' '
+   ENDDO
+ENDIF
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+
+! Write offsets
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+   '        <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">'
+
+WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+   DO I=1,SIZE(OFFSETS)
+      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') OFFSETS(I), ' '
+   ENDDO
+ENDIF
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+
+! Write cell types
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+   '        <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">'
+
+WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+   DO I=1,SIZE(CELL_TYPE)
+      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' '
+   ENDDO
+ENDIF
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+
+! Close cell section
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </Cells>'
+
+! Open point data section
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <PointData>'
+
+CLOSE(LU_VTK(NM))
+
+END SUBROUTINE WRITE_VTK_SLICE_CELLS
+
+SUBROUTINE WRITE_VTK_SLICE_DATA(NM, DATA, DATA_NAME, FORMAT)
+
+INTEGER, INTENT(IN) :: NM
+CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME
+CHARACTER(LEN=:), ALLOCATABLE :: CODE
+REAL(FB), DIMENSION(:) :: DATA
+INTEGER :: I
+
+! Open data section
+OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+
+! Write data
+WRITE(LU_VTK(NM),'(A,A,A,A,A)',ADVANCE='YES') &
+   '        <DataArray type="Float32" NumberOfComponents="1" Name="',&
+  TRIM(DATA_NAME),'" format="',FORMAT,'">'
+
+WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
+   DO I=1,SIZE(DATA)
+      WRITE(LU_VTK(NM),'(E15.8,A)',ADVANCE='NO') DATA(I), ' '
+   ENDDO
+ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN
+   !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA)
+   !WRITE(LU_VTK(NM)) CODE
+ENDIF
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+
+! Close data section
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+CLOSE(LU_VTK(NM))
+
+END SUBROUTINE WRITE_VTK_SLICE_DATA
+
+SUBROUTINE FINALIZE_VTK(NM,MESH_TOPOLOGY)
+
+INTEGER, INTENT(IN) :: NM
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+
+! Close VTK file
+OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </PointData>'
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '    </Piece>'
+WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
+WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '</VTKFile>'
+
+CLOSE(LU_VTK(NM))
+END SUBROUTINE FINALIZE_VTK
+
+END MODULE VTK
+
+!FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE)
+!!< Encode (Base64) a dataarray with 1 components of rank 1 (FB).
+!REAL(FB), INTENT(IN)          :: X(1:) !< Data variable.
+!CHARACTER(len=:), ALLOCATABLE :: CODE  !< Encoded base64 dataarray.
+!INTEGER(IB16)                  :: N     !< Counter.
+!INTEGER(IB16)                  :: L     !< Length
+!INTEGER(IB16)                  :: SP    !< String pointer
+!INTEGER(IB16)                  :: SIZE_N!< Dimension size
+!
+!SIZE_N = SIZE(X,DIM=1)
+!L = DI2P+1
+!SP = 0
+!CODE = REPEAT(' ',L*SIZE_N)
+!DO N = 1,SIZE_N
+!    CODE(SP+1:SP+L) = STR(N=X(N))
+!    SP = SP + L
+!ENDDO
+!ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB
+!
+!END MODULE VTK

From 12c916597b1bc3cd5cbb1810de2cc5899e47a8b1 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Thu, 28 Dec 2023 22:18:29 -0500
Subject: [PATCH 17/31] swap to custom vtk module

---
 Source/dump.f90 | 32 --------------------------------
 1 file changed, 32 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 3e01a6c32d4..d0432b95d2d 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,10 +19,6 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
-#ifdef WITH_VTK
-USE PENF
-USE VTK_FORTRAN, ONLY : VTK_FILE
-#endif /* WITH_VTK */
 USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
                 FINALIZE_VTK
 
@@ -136,7 +132,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
-#ifdef WITH_VTK
 IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
    CALL DUMP_SLCF(T,DT,NM,3)
    DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1)
@@ -144,7 +139,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
       IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT
    ENDDO
 ENDIF
-#endif /* WITH_VTK */
 
 IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN
    CALL DUMP_BNDF(T,DT,NM)
@@ -5813,8 +5807,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE
 REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX
 INTEGER :: IERROR
-TYPE(VTK_FILE)     :: A_VTK_FILE                             ! A VTK file.
-INTEGER(IB4)  :: VTK_ERROR=0_IB4                    !< IO Error status.
 LOGICAL :: VTK_INITIALIZED
 
 ! Return if there are no slices to process and this is not a Plot3D dump
@@ -5973,11 +5965,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       ENDIF
       WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-         IF (VTK_BINARY) THEN
-            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='BINARY', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
-         ELSE
-            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ASCII', FILENAME=FN_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
-         ENDIF ! do not change capitalization on mesh topology
          
          I1=SL%I1
          I2=SL%I2
@@ -6035,16 +6022,9 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
             CELL_TYPE(I) = 11_IB4
          ENDDO
          
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, CELL_TYPE=CELL_TYPE)
-         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='OPEN')
-         
-         WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
          CALL INITIALIZE_VTK(NM,'UnstructuredGrid')
          CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii')
          CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii')
-         WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
          
          DEALLOCATE(OFFSETS)
          DEALLOCATE(CELL_TYPE)
@@ -6345,12 +6325,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
                ENDDO
             ENDDO
             
-            ! write one quantity
-            VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
-            
-            WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
             CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
-            WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
             
             DEALLOCATE(QQ_PACK)
          ENDIF
@@ -6361,14 +6336,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 IF (VTK3D) THEN
    ! finish after writing all pieces
-   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_DATAARRAY(LOCATION='NODE', ACTION='CLOSE')
-   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
-   VTK_ERROR = A_VTK_FILE%FINALIZE()
-   
-   WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'_new.vtu'
    CALL FINALIZE_VTK(NM,'UnstructuredGrid')
-   WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
-   
 ENDIF
 
 ! Write out the PLOT3D ``q'' file

From e17c7a971a7025d0bd4da4359c4cdaa1d47a9def Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Fri, 29 Dec 2023 12:16:00 -0500
Subject: [PATCH 18/31] locate vtk files in results/ directory

---
 Source/c_mkdir.c   | 11 +++++++++++
 Source/dump.f90    |  6 +++++-
 Source/f_mkdir.f90 | 12 ++++++++++++
 Source/vtk.f90     |  1 -
 4 files changed, 28 insertions(+), 2 deletions(-)
 create mode 100644 Source/c_mkdir.c
 create mode 100644 Source/f_mkdir.f90

diff --git a/Source/c_mkdir.c b/Source/c_mkdir.c
new file mode 100644
index 00000000000..de730241478
--- /dev/null
+++ b/Source/c_mkdir.c
@@ -0,0 +1,11 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+void c_mkdir(const char*directory){
+  struct stat st = {0};
+  if (stat(directory, &st) == -1) {
+      mkdir(directory, 0700);
+  }
+}
+
diff --git a/Source/dump.f90 b/Source/dump.f90
index d0432b95d2d..b8ed92c7e8c 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -22,6 +22,9 @@ MODULE DUMP
 USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
                 FINALIZE_VTK
 
+USE F_MKDIR, ONLY : C_MKDIR
+USE ISO_C_BINDING
+
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
@@ -5963,7 +5966,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
-      WRITE(FN_VTK(NM),'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
+      WRITE(FN_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          
          I1=SL%I1
@@ -6022,6 +6025,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
             CELL_TYPE(I) = 11_IB4
          ENDDO
          
+         CALL C_MKDIR("./results"//char(0))
          CALL INITIALIZE_VTK(NM,'UnstructuredGrid')
          CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii')
          CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii')
diff --git a/Source/f_mkdir.f90 b/Source/f_mkdir.f90
new file mode 100644
index 00000000000..5ee69b0f6e6
--- /dev/null
+++ b/Source/f_mkdir.f90
@@ -0,0 +1,12 @@
+MODULE F_MKDIR
+
+  USE ISO_C_BINDING
+
+  INTERFACE
+    SUBROUTINE C_MKDIR(DIRECTORY) BIND(C)
+      USE ISO_C_BINDING
+      CHARACTER(KIND=C_CHAR),INTENT(IN) :: DIRECTORY(*)
+    END SUBROUTINE
+  END INTERFACE
+
+END MODULE
diff --git a/Source/vtk.f90 b/Source/vtk.f90
index 37329eebe77..59fe3780ee6 100644
--- a/Source/vtk.f90
+++ b/Source/vtk.f90
@@ -16,7 +16,6 @@ SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY)
 
 INTEGER, INTENT(IN) :: NM
 CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
-
 OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED')
 WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
 WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'

From 29af7f755163a0dfe2f4b7d8d83b6c51683c9826 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 30 Dec 2023 21:47:17 -0500
Subject: [PATCH 19/31] add SMOKE3D VTK output

---
 Source/cons.f90 |  56 +++---
 Source/dump.f90 | 183 +++++++++---------
 Source/func.f90 |   3 +-
 Source/vtk.f90  | 482 +++++++++++++++++++++++++++++++++++++++++-------
 4 files changed, 540 insertions(+), 184 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 6f61fa3c0bf..18ccfd1d280 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -535,7 +535,7 @@ MODULE GLOBAL_CONSTANTS
 INTEGER                              :: LU_HISTOGRAM,LU_HVAC
 INTEGER                              :: LU_GEOC=-1,LU_TGA,LU_INFO,LU_DEVC_CTRL=-1,LU_STL
 INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_PART,LU_PROF,LU_XYZ,LU_TERRAIN,LU_PL3D,LU_DEVC,LU_STATE,LU_CTRL,LU_CORE,LU_RESTART
-INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_VTK
+INTEGER, ALLOCATABLE, DIMENSION(:)   :: LU_VEG_OUT,LU_GEOM,LU_CFACE_GEOM,LU_SL3D_VTK,LU_SMOKE3D_VTK
 INTEGER                              :: LU_GEOM_TRAN
 INTEGER, ALLOCATABLE, DIMENSION(:,:) :: LU_SLCF,LU_SLCF_GEOM,LU_BNDF,LU_BNDG,LU_ISOF,LU_ISOF2, &
                                         LU_SMOKE3D,LU_RADF
@@ -546,10 +546,10 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(80)                              :: FN_MASS,FN_HRR,FN_STEPS,FN_SMV,FN_END,FN_ERR,FN_NOTREADY,FN_VELOCITY_ERROR,FN_GIT
 CHARACTER(80)                              :: FN_LINE,FN_HISTOGRAM,FN_CUTCELL,FN_TGA,FN_DEVC_CTRL,FN_HVAC,FN_STL
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_PART,FN_PROF,FN_XYZ,FN_TERRAIN,FN_PL3D,FN_DEVC,FN_STATE,FN_CTRL,FN_CORE,FN_RESTART
-CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM, FN_VTK
+CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, &
                                               FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF
-
+CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK
 
 CHARACTER(9) :: FMT_R
 LOGICAL :: OUT_FILE_OPENED=.FALSE.
@@ -739,35 +739,37 @@ MODULE OUTPUT_CLOCKS
 USE PRECISION_PARAMETERS
 IMPLICIT NONE (TYPE,EXTERNAL)
 
-INTEGER :: RAMP_BNDF_INDEX=0  !< Ramp index for boundary file time series
-INTEGER :: RAMP_CTRL_INDEX=0  !< Ramp index for control file time series
-INTEGER :: RAMP_CPU_INDEX =0  !< Ramp index for CPU file time series
-INTEGER :: RAMP_DEVC_INDEX=0  !< Ramp index for device file time series
-INTEGER :: RAMP_FLSH_INDEX=0  !< Ramp index for flush time series
-INTEGER :: RAMP_GEOM_INDEX=0  !< Ramp index for geometry output
-INTEGER :: RAMP_HRR_INDEX =0  !< Ramp index for hrr file time series
-INTEGER :: RAMP_HVAC_INDEX=0  !< Ramp index for hvac file time series
-INTEGER :: RAMP_ISOF_INDEX=0  !< Ramp index for isosurface file time series
-INTEGER :: RAMP_MASS_INDEX=0  !< Ramp index for mass file time series
-INTEGER :: RAMP_PART_INDEX=0  !< Ramp index for particle file time series
-INTEGER :: RAMP_PL3D_INDEX=0  !< Ramp index for Plot3D file time series
-INTEGER :: RAMP_PROF_INDEX=0  !< Ramp index for profile file time series
-INTEGER :: RAMP_RADF_INDEX=0  !< Ramp index for radiation file time series
-INTEGER :: RAMP_RSRT_INDEX=0  !< Ramp index for restart file time series
-INTEGER :: RAMP_SLCF_INDEX=0  !< Ramp index for slice file time series
-INTEGER :: RAMP_SL3D_INDEX=0  !< Ramp index for 3D slice file time series
-INTEGER :: RAMP_SM3D_INDEX=0  !< Ramp index for smoke3d file time series
-INTEGER :: RAMP_UVW_INDEX =0  !< Ramp index for velocity file time series
-INTEGER :: RAMP_TMP_INDEX =0  !< Ramp index for temperature file time series
-INTEGER :: RAMP_SPEC_INDEX=0  !< Ramp index for species file time series
-INTEGER :: RAMP_VTK_INDEX=0   !< Ramp index for vtk file time series
+INTEGER :: RAMP_BNDF_INDEX=0       !< Ramp index for boundary file time series
+INTEGER :: RAMP_CTRL_INDEX=0       !< Ramp index for control file time series
+INTEGER :: RAMP_CPU_INDEX =0       !< Ramp index for CPU file time series
+INTEGER :: RAMP_DEVC_INDEX=0       !< Ramp index for device file time series
+INTEGER :: RAMP_FLSH_INDEX=0       !< Ramp index for flush time series
+INTEGER :: RAMP_GEOM_INDEX=0       !< Ramp index for geometry output
+INTEGER :: RAMP_HRR_INDEX =0       !< Ramp index for hrr file time series
+INTEGER :: RAMP_HVAC_INDEX=0       !< Ramp index for hvac file time series
+INTEGER :: RAMP_ISOF_INDEX=0       !< Ramp index for isosurface file time series
+INTEGER :: RAMP_MASS_INDEX=0       !< Ramp index for mass file time series
+INTEGER :: RAMP_PART_INDEX=0       !< Ramp index for particle file time series
+INTEGER :: RAMP_PL3D_INDEX=0       !< Ramp index for Plot3D file time series
+INTEGER :: RAMP_PROF_INDEX=0       !< Ramp index for profile file time series
+INTEGER :: RAMP_RADF_INDEX=0       !< Ramp index for radiation file time series
+INTEGER :: RAMP_RSRT_INDEX=0       !< Ramp index for restart file time series
+INTEGER :: RAMP_SLCF_INDEX=0       !< Ramp index for slice file time series
+INTEGER :: RAMP_SL3D_INDEX=0       !< Ramp index for 3D slice file time series
+INTEGER :: RAMP_SM3D_INDEX=0       !< Ramp index for smoke3d file time series
+INTEGER :: RAMP_UVW_INDEX =0       !< Ramp index for velocity file time series
+INTEGER :: RAMP_TMP_INDEX =0       !< Ramp index for temperature file time series
+INTEGER :: RAMP_SPEC_INDEX=0       !< Ramp index for species file time series
+INTEGER :: RAMP_SL3D_VTK_INDEX=0   !< Ramp index for vtk file time series
+INTEGER :: RAMP_SM3D_VTK_INDEX=0   !< Ramp index for vtk file time series
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,&
                                        ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,&
-                                       SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,VTK_CLOCK
+                                       SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,&
+                                       SL3D_VTK_CLOCK,SM3D_VTK_CLOCK
 INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,&
                                       HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,&
                                       RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,&
-                                      VTK_COUNTER
+                                      SL3D_VTK_COUNTER,SM3D_VTK_COUNTER
 REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB
 REAL(EB) :: MMS_TIMER=1.E10_EB
 REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,&
diff --git a/Source/dump.f90 b/Source/dump.f90
index b8ed92c7e8c..f81e5ff0d0e 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -20,7 +20,7 @@ MODULE DUMP
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
 USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
-                FINALIZE_VTK
+                FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER
 
 USE F_MKDIR, ONLY : C_MKDIR
 USE ISO_C_BINDING
@@ -112,7 +112,8 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN
-   CALL DUMP_SMOKE3D(T,DT,NM)
+   CALL C_MKDIR("./results"//char(0))
+   CALL DUMP_SMOKE3D(T,DT,NM,0)
    DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1)
       SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1
       IF (SM3D_CLOCK(SM3D_COUNTER(NM))>=T) EXIT
@@ -120,6 +121,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN
+   CALL C_MKDIR("./results"//char(0))
    CALL DUMP_SLCF(T,DT,NM,0)
    DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1)
       SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1
@@ -135,11 +137,27 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
-IF (T>=VTK_CLOCK(VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
+! VTK 3-D slices
+IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
+   IF (NM .EQ. 1) THEN
+      CALL WRITE_VTK_SLICE_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+   ENDIF
    CALL DUMP_SLCF(T,DT,NM,3)
-   DO WHILE(VTK_COUNTER(NM)<SIZE(VTK_CLOCK)-1)
-      VTK_COUNTER(NM) = VTK_COUNTER(NM) + 1
-      IF (VTK_CLOCK(VTK_COUNTER(NM))>=T) EXIT
+   DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1)
+      SL3D_VTK_COUNTER(NM) = SL3D_VTK_COUNTER(NM) + 1
+      IF (SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM))>=T) EXIT
+   ENDDO
+ENDIF
+
+! VTK Smoke 3D slices
+IF (T>=SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
+   IF (NM .EQ. 1) THEN
+      CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+   ENDIF
+   CALL DUMP_SMOKE3D(T,DT,NM,1)
+   DO WHILE(SM3D_VTK_COUNTER(NM)<SIZE(SM3D_VTK_CLOCK)-1)
+      SM3D_VTK_COUNTER(NM) = SM3D_VTK_COUNTER(NM) + 1
+      IF (SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM))>=T) EXIT
    ENDDO
 ENDIF
 
@@ -340,8 +358,6 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(LU_XYZ(NMESHES))
 ALLOCATE(FN_PL3D(2*NMESHES))
 ALLOCATE(LU_PL3D(2*NMESHES))
-ALLOCATE(FN_VTK(NMESHES))
-ALLOCATE(LU_VTK(NMESHES))
 
 ALLOCATE(FN_ISOF(N_ISOF,NMESHES))
 ALLOCATE(LU_ISOF(N_ISOF,NMESHES))
@@ -378,6 +394,12 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(FN_RESTART(NMESHES))
 ALLOCATE(LU_RESTART(NMESHES))
 
+! VTK Files
+ALLOCATE(FN_SL3D_VTK(NMESHES+1))
+ALLOCATE(LU_SL3D_VTK(NMESHES+1))
+ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1))
+ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1))
+
 MESH_LOOP: DO NM=1,NMESHES
 
    IF (PROCESS(NM)/=MY_RANK) CYCLE MESH_LOOP
@@ -490,7 +512,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
    WRITE(FN_CORE(NM),   '(A,A,I0,A)') TRIM(CHID),'_',NM,'.restart'
    
    ! VTK Files
-   LU_VTK(NM)              = GET_FILE_NUMBER() ! slice file
+   LU_SL3D_VTK(NM)              = GET_FILE_NUMBER() ! slice file
       
 
 ENDDO MESH_LOOP
@@ -4255,21 +4277,29 @@ END SUBROUTINE DUMP_ISOF
 !> \param T Current simulation time (s)
 !> \param DT Current time step size (s)
 !> \param NM Mesh number
+!> \param IFRMT SMV (IFRMT=0) or VTK (IFRMT=1)
 
-SUBROUTINE DUMP_SMOKE3D(T,DT,NM)
+SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
 
 USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE
 REAL(EB), INTENT(IN) :: T,DT
-INTEGER,  INTENT(IN) :: NM
-INTEGER  :: I,J,K,N
+INTEGER,  INTENT(IN) :: NM,IFRMT
+INTEGER  :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1
 REAL(FB) :: DXX,STIME
 REAL(EB), POINTER, DIMENSION(:,:,:) :: FF
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
-REAL(EB) :: FR_C
+REAL(EB) :: FR_C,TT
 TYPE(SMOKE3D_TYPE), POINTER :: S3
+LOGICAL :: SMV_OUT,VTK_OUT
 
 CALL POINT_TO_MESH(NM)
 
+! Swap case
+SELECT CASE(IFRMT)
+   CASE(0) ; SMV_OUT=.TRUE. ; VTK_OUT=.FALSE.
+   CASE(1) ; SMV_OUT=.FALSE. ; VTK_OUT=.TRUE.
+END SELECT
+
 ! Miscellaneous settings
 
 DRY   = .FALSE.
@@ -4323,13 +4353,52 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM)
 
    ! Pack the data into a 1-D array and send to the routine that writes the file for Smokeview
 
-   ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1))
-   QQ_PACK = PACK(QQ(0:IBAR,0:JBAR,0:KBAR,1),MASK=.TRUE.)
-   CALL SMOKE3D_TO_FILE(NM,STIME,DXX,N,QQ_PACK,IBP1,JBP1,KBP1,SMOKE3D_16)
+   IF (SMV_OUT) THEN
+      ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1))
+      QQ_PACK = PACK(QQ(0:IBAR,0:JBAR,0:KBAR,1),MASK=.TRUE.)
+      CALL SMOKE3D_TO_FILE(NM,STIME,DXX,N,QQ_PACK,IBP1,JBP1,KBP1,SMOKE3D_16)
+   ENDIF
+   IF (VTK_OUT) THEN
+      TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+      ITM  = INT(TT)
+      ITM1 = NINT(ABS(TT-ITM)*100)
+      IF (ITM1==100) THEN
+         ITM = ITM+1
+         ITM1 = 0
+      ENDIF
+      WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
+      !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1
+      ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1))
+      DO I = 0, IBAR
+         IFACT = I
+         DO J = 0, JBAR
+            JFACT = J*(IBAR)
+            DO K = 0, KBAR
+               KFACT = K*(JBAR)*(IBAR)
+               QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1)
+            ENDDO
+         ENDDO
+      ENDDO
+      IF (N .EQ. 1) THEN
+         CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
+         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), LU_SMOKE3D_VTK(NM))
+      ENDIF
+      IF (VTK_BINARY) THEN
+         CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
+                                   QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+      ELSE
+         CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
+                                   QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+      ENDIF
+   ENDIF
    DEALLOCATE(QQ_PACK)
 
 ENDDO DATA_FILE_LOOP
 
+IF (VTK_OUT) THEN
+   CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
+ENDIF
+
 END SUBROUTINE DUMP_SMOKE3D
 
 
@@ -5966,76 +6035,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
-      WRITE(FN_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_',NM,'_',ITM,ITM1,'.vtu'
+      WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-         
-         I1=SL%I1
-         I2=SL%I2
-         J1=SL%J1
-         J2=SL%J2
-         K1=SL%K1
-         K2=SL%K2
-         NX = I2 + 1 - I1
-         NY = J2 + 1 - J1
-         NZ = K2 + 1 - K1
-         NP = NX*NY*NZ
-         NC = (NX-1)*(NY-1)*(NZ-1)
-         
-         ! Fill point data
-         ALLOCATE(X_PTS(NP))
-         ALLOCATE(Y_PTS(NP))
-         ALLOCATE(Z_PTS(NP))
-         IFACT = 1
-         DO K = 0, NZ-1
-            DO J = 0, NY-1
-               DO I = 0, NX-1
-                  X_PTS(IFACT)=MESHES(NM)%X(I)
-                  Y_PTS(IFACT)=MESHES(NM)%Y(J)
-                  Z_PTS(IFACT)=MESHES(NM)%Z(K)
-                  IFACT = IFACT + 1
-               ENDDO
-            ENDDO
-         ENDDO
-         
-         ! Fill cell data
-         ALLOCATE(CONNECT(NC*8))
-         DO I = 1, NX-1
-            IFACT = (I-1)
-            DO J = 1, NY-1
-               JFACT = (J-1)*(NX-1)
-               DO K = 1, NZ-1
-                  KFACT = (K - 1)*(NY-1)*(NX-1)
-                  CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1
-                  CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I
-                  CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1
-                  CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I
-                  CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1
-                  CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I
-                  CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1
-                  CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I
-               ENDDO
-            ENDDO
-         ENDDO
-         
-         ALLOCATE(OFFSETS(NC))
-         ALLOCATE(CELL_TYPE(NC))
-         
-         DO I=1,NC
-            OFFSETS(I) = (I)*8_IB4
-            CELL_TYPE(I) = 11_IB4
-         ENDDO
-         
-         CALL C_MKDIR("./results"//char(0))
-         CALL INITIALIZE_VTK(NM,'UnstructuredGrid')
-         CALL WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, 'ascii')
-         CALL WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, 'ascii')
-         
-         DEALLOCATE(OFFSETS)
-         DEALLOCATE(CELL_TYPE)
-         DEALLOCATE(CONNECT)
-         DEALLOCATE(X_PTS)
-         DEALLOCATE(Y_PTS)
-         DEALLOCATE(Z_PTS)
+         CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
+         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM))
       ENDIF
       VTK_INITIALIZED=.TRUE.
    ENDIF
@@ -6329,7 +6332,13 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
                ENDDO
             ENDDO
             
-            CALL WRITE_VTK_SLICE_DATA(NM, QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            IF (VTK_BINARY) THEN
+               CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
+                                         QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            ELSE
+               CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
+                                         QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            ENDIF
             
             DEALLOCATE(QQ_PACK)
          ENDIF
@@ -6340,7 +6349,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 IF (VTK3D) THEN
    ! finish after writing all pieces
-   CALL FINALIZE_VTK(NM,'UnstructuredGrid')
+   CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
 ENDIF
 
 ! Write out the PLOT3D ``q'' file
diff --git a/Source/func.f90 b/Source/func.f90
index bd92f564667..4e05f7605a0 100644
--- a/Source/func.f90
+++ b/Source/func.f90
@@ -481,7 +481,8 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T)
 CALL SET_OUTPUT_CLOCK(DT_UVW    ,RAMP_UVW_INDEX , UVW_CLOCK, UVW_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_TMP    ,RAMP_TMP_INDEX , TMP_CLOCK, TMP_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_SPEC   ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. )
-CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_VTK_INDEX,  VTK_CLOCK, VTK_COUNTER,.TRUE. ,.TRUE. )
+CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SL3D_VTK_INDEX,  SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. )
+CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SM3D_VTK_INDEX,  SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. )
 
 ! Special cases
 
diff --git a/Source/vtk.f90 b/Source/vtk.f90
index 59fe3780ee6..3af31662e85 100644
--- a/Source/vtk.f90
+++ b/Source/vtk.f90
@@ -4,160 +4,504 @@ MODULE VTK
 
 USE MESH_VARIABLES
 USE GLOBAL_CONSTANTS
+USE MESH_POINTERS
+USE OUTPUT_DATA
 
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
-PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK
+PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK,&
+       WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER
 
 CONTAINS
 
-SUBROUTINE INITIALIZE_VTK(NM,MESH_TOPOLOGY)
+SUBROUTINE INITIALIZE_VTK(LU,FN,MESH_TOPOLOGY)
 
-INTEGER, INTENT(IN) :: NM
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
-OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED')
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),'>'
-CLOSE(LU_VTK(NM))
+INTEGER, INTENT(IN) :: LU
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN
+OPEN(LU,FILE=FN,FORM='FORMATTED')
+WRITE(LU,'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
+WRITE(LU,'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
+WRITE(LU,'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),'>'
+CLOSE(LU)
 END SUBROUTINE INITIALIZE_VTK
 
-SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(NM, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT)
+SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(LU, FN, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT)
 
-INTEGER, INTENT(IN) :: NM, NC, NP
+INTEGER, INTENT(IN) :: LU, NC, NP
 REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS
-CHARACTER(LEN=*), INTENT(IN) :: FORMAT
+CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT
 INTEGER :: I
 
-OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU_VTK(NM),'(A,I0,A,I0,A)',ADVANCE='YES') '    <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">'
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <Points>'
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU,'(A,I0,A,I0,A)',ADVANCE='YES') '    <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">'
+WRITE(LU,'(A)',ADVANCE='YES') '      <Points>'
+WRITE(LU,'(A,A,A)',ADVANCE='YES') &
    '        <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">'
 
-WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+WRITE(LU,'(A)',ADVANCE='NO') '          '
 IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
    DO I=1,NP
-      WRITE(LU_VTK(NM),'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' '
+      WRITE(LU,'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' '
    ENDDO
 ENDIF
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </Points>'
-CLOSE(LU_VTK(NM))
+WRITE(LU,'(A)',ADVANCE='YES') ' '
+WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
+WRITE(LU,'(A)',ADVANCE='YES') '      </Points>'
+CLOSE(LU)
 
 END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY
 
-SUBROUTINE WRITE_VTK_SLICE_CELLS(NM, CONNECT, OFFSETS, CELL_TYPE, FORMAT)
+SUBROUTINE WRITE_VTK_SLICE_CELLS(LU, FN, CONNECT, OFFSETS, CELL_TYPE, FORMAT)
 
-INTEGER, INTENT(IN) :: NM
+INTEGER, INTENT(IN) :: LU
 INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS
 INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: FORMAT
+CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT
 INTEGER :: I
 
 ! Open cells section
-OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <Cells>'
+OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU,'(A)',ADVANCE='YES') '      <Cells>'
 
 ! Write connectivity
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+WRITE(LU,'(A,A,A)',ADVANCE='YES') &
    '        <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">'
 
-WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+WRITE(LU,'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
    DO I=1,SIZE(CONNECT)
-      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CONNECT(I), ' '
+      WRITE(LU,'(I0,A)',ADVANCE='NO') CONNECT(I), ' '
    ENDDO
 ENDIF
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+WRITE(LU,'(A)',ADVANCE='YES') ' '
+WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
 
 ! Write offsets
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+WRITE(LU,'(A,A,A)',ADVANCE='YES') &
    '        <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">'
 
-WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+WRITE(LU,'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
    DO I=1,SIZE(OFFSETS)
-      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') OFFSETS(I), ' '
+      WRITE(LU,'(I0,A)',ADVANCE='NO') OFFSETS(I), ' '
    ENDDO
 ENDIF
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+WRITE(LU,'(A)',ADVANCE='YES') ' '
+WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
 
 ! Write cell types
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') &
+WRITE(LU,'(A,A,A)',ADVANCE='YES') &
    '        <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">'
 
-WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
+WRITE(LU,'(A)',ADVANCE='NO') '          '
+IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
    DO I=1,SIZE(CELL_TYPE)
-      WRITE(LU_VTK(NM),'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' '
+      WRITE(LU,'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' '
    ENDDO
 ENDIF
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
+WRITE(LU,'(A)',ADVANCE='YES') ' '
+WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
 
 ! Close cell section
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </Cells>'
+WRITE(LU,'(A)',ADVANCE='YES') '      </Cells>'
 
 ! Open point data section
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      <PointData>'
+WRITE(LU,'(A)',ADVANCE='YES') '      <PointData>'
 
-CLOSE(LU_VTK(NM))
+CLOSE(LU)
 
 END SUBROUTINE WRITE_VTK_SLICE_CELLS
 
-SUBROUTINE WRITE_VTK_SLICE_DATA(NM, DATA, DATA_NAME, FORMAT)
+SUBROUTINE WRITE_VTK_SLICE_DATA(LU, FN, DATA, DATA_NAME, FORMAT)
 
-INTEGER, INTENT(IN) :: NM
-CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME
+INTEGER, INTENT(IN) :: LU
+CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME, FN
 CHARACTER(LEN=:), ALLOCATABLE :: CODE
 REAL(FB), DIMENSION(:) :: DATA
-INTEGER :: I
+INTEGER :: I, NBITS_DATA, NSTRINGS_DATA
+CHARACTER(LEN=:), ALLOCATABLE :: BIT_DATA
+
+!real(R16P),                    intent(in)  :: n       !< Number to be encoded.
+integer(I1P),     allocatable              :: nI1P(:) !< One byte integer array containing n.
+integer(I4P)                               :: padd    !< Number of padding characters ('=').
+
+integer(I4P) :: BYR16P = 2_I1P
+
+
+
 
 ! Open data section
-OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
 
 ! Write data
-WRITE(LU_VTK(NM),'(A,A,A,A,A)',ADVANCE='YES') &
+WRITE(LU,'(A,A,A,A,A)',ADVANCE='YES') &
    '        <DataArray type="Float32" NumberOfComponents="1" Name="',&
   TRIM(DATA_NAME),'" format="',FORMAT,'">'
 
-WRITE(LU_VTK(NM),'(A)',ADVANCE='NO') '          '
+WRITE(LU,'(A)',ADVANCE='NO') '          '
 IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
    DO I=1,SIZE(DATA)
-      WRITE(LU_VTK(NM),'(E15.8,A)',ADVANCE='NO') DATA(I), ' '
+      WRITE(LU,'(E15.8,A)',ADVANCE='NO') DATA(I), ' '
    ENDDO
 ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN
+   CLOSE(LU)
+   OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
+   !NBITS_DATA = SIZE(DATA) * SIZEOF(FB)*2
+   !NSTRINGS_DATA = INT(FLOAT(NBITS_DATA)/3+0.9)
+   
+   allocate(nI1P(1:((BYR16P+2)/3)*3)) ; nI1P = 0_I1P
+   code = repeat(' ',((BYR16P+2)/3)*4)
+   nI1P = transfer(DATA,nI1P)
+   padd = mod((BYR16P),3) ; if (padd>0_I4P) padd = 3_I4P - padd
+
+
+   
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   
+   WRITE(*,*) "SIZES", SIZE(DATA), NBITS_DATA
+   WRITE(*,*) PADD
+   WRITE(*,*) CODE
+   !ALLOCATE(CHARACTER(LEN=NBITS_DATA) :: BIT_DATA)
+   !WRITE(BIT_DATA,'(B64)') DATA
+   !WRITE(*,*) BIT_DATA
+   !DEALLOCATE(BIT_DATA)
+   !DO I=0,NSTRINGS_DATA
+   !   STRINGBITS = DATA(I*6:(I+1)*6)
+   !   WRITE(*,*), "DATA ", I, " ", STRINGBITS
+   !ENDDO
+   !WRITE(LU_SL3D_VTK(NM)) NBITS_DATA  , (DATA(I),I=1,SIZE(DATA))
+   CLOSE(LU)
+   OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+   !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA)
+   !WRITE(LU_SL3D_VTK(NM)) CODE
+ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'appended') THEN
+   CLOSE(LU)
+   OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
+   NBITS_DATA = SIZE(DATA) * SIZEOF(FB)
+   WRITE(LU) NBITS_DATA  , (DATA(I),I=1,SIZE(DATA))
+   CLOSE(LU)
+   OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
    !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA)
-   !WRITE(LU_VTK(NM)) CODE
+   !WRITE(LU_SL3D_VTK(NM)) CODE
 ENDIF
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') ' '
+WRITE(LU,'(A)',ADVANCE='YES') ' '
 
 ! Close data section
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '        </DataArray>'
-CLOSE(LU_VTK(NM))
+WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
+CLOSE(LU)
 
 END SUBROUTINE WRITE_VTK_SLICE_DATA
 
-SUBROUTINE FINALIZE_VTK(NM,MESH_TOPOLOGY)
+SUBROUTINE FINALIZE_VTK(LU,FN,MESH_TOPOLOGY)
 
-INTEGER, INTENT(IN) :: NM
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+INTEGER, INTENT(IN) :: LU
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN
 
 ! Close VTK file
-OPEN(LU_VTK(NM),FILE=FN_VTK(NM),FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '      </PointData>'
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '    </Piece>'
-WRITE(LU_VTK(NM),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
-WRITE(LU_VTK(NM),'(A)',ADVANCE='YES') '</VTKFile>'
+OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
+WRITE(LU,'(A)',ADVANCE='YES') '      </PointData>'
+WRITE(LU,'(A)',ADVANCE='YES') '    </Piece>'
+WRITE(LU,'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
+WRITE(LU,'(A)',ADVANCE='YES') '</VTKFile>'
 
-CLOSE(LU_VTK(NM))
+CLOSE(LU)
 END SUBROUTINE FINALIZE_VTK
 
+SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+TYPE (SLICE_TYPE), POINTER :: SL
+INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
+REAL(FB) :: STIME
+REAL(EB) :: TT
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu'
+
+! First part of header before quantities
+OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED')
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
+   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
+
+! Add PointData arrays
+NQT = MESHES(1)%N_SLCF
+QUANTITY_LOOP2: DO IQ=1,NQT
+   SL => SLICE(IQ)
+   I1  = SL%I1
+   I2  = SL%I2
+   J1  = SL%J1
+   J2  = SL%J2
+   K1  = SL%K1
+   K2  = SL%K2
+   IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format='
+   IF (VTK_BINARY) THEN
+      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+   ELSE
+      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+   ENDIF
+ENDDO QUANTITY_LOOP2
+
+! Close PointData
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
+
+! Add Point arrays
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
+IF (VTK_BINARY) THEN
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+ELSE
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+ENDIF
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
+
+! Add CellData
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
+
+! Write pieces
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu'
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
+ENDDO
+
+! Finalize file
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
+CLOSE(LU_SL3D_VTK(NMESHES+1))
+END SUBROUTINE WRITE_VTK_SLICE_WRAPPER
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+TYPE (SLICE_TYPE), POINTER :: SL
+INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1,N
+REAL(FB) :: STIME
+REAL(EB) :: TT
+CHARACTER(200) :: TMP_FILE
+TYPE(SMOKE3D_TYPE), POINTER :: S3
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu'
+
+! First part of header before quantities
+OPEN(LU_SMOKE3D_VTK(NMESHES+1),FILE=FN_SMOKE3D_VTK(NMESHES+1),FORM='FORMATTED')
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
+   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
+
+! Add PointData arrays
+DATA_FILE_LOOP2: DO N=1,N_SMOKE3D
+
+   S3 => SMOKE3D_FILE(N)
+   WRITE(*,*) "SMOKE3D QUANTITY", S3%SMOKEVIEW_LABEL(1:30)
+   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
+   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(S3%SMOKEVIEW_LABEL(1:30)),'" format='
+   IF (VTK_BINARY) THEN
+      WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+   ELSE
+      WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+   ENDIF
+ENDDO DATA_FILE_LOOP2
+
+! Close PointData
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
+
+! Add Point arrays
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
+IF (VTK_BINARY) THEN
+   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+ELSE
+   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+ENDIF
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
+
+! Add CellData
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
+
+! Write pieces
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu'
+   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
+ENDDO
+
+! Finalize file
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
+WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
+CLOSE(LU_SMOKE3D_VTK(NMESHES+1))
+END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
+
+
+
+SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, LU)
+
+INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS
+INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN
+INTEGER, INTENT(IN) :: NM, LU
+
+NX = SIZE(MESHES(NM)%X)
+NY = SIZE(MESHES(NM)%Y)
+NZ = SIZE(MESHES(NM)%Z)
+
+NP = NX*NY*NZ
+NC = (NX-1)*(NY-1)*(NZ-1)
+
+! Fill point data
+ALLOCATE(X_PTS(NP))
+ALLOCATE(Y_PTS(NP))
+ALLOCATE(Z_PTS(NP))
+IFACT = 1
+DO K = 0, NZ-1
+   DO J = 0, NY-1
+      DO I = 0, NX-1
+         X_PTS(IFACT)=MESHES(NM)%X(I)
+         Y_PTS(IFACT)=MESHES(NM)%Y(J)
+         Z_PTS(IFACT)=MESHES(NM)%Z(K)
+         IFACT = IFACT + 1
+      ENDDO
+   ENDDO
+ENDDO
+
+! Fill cell data
+ALLOCATE(CONNECT(NC*8))
+DO I = 1, NX-1
+   IFACT = (I-1)
+   DO J = 1, NY-1
+      JFACT = (J-1)*(NX-1)
+      DO K = 1, NZ-1
+         KFACT = (K - 1)*(NY-1)*(NX-1)
+         CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I
+      ENDDO
+   ENDDO
+ENDDO
+
+ALLOCATE(OFFSETS(NC))
+ALLOCATE(CELL_TYPE(NC))
+
+DO I=1,NC
+   OFFSETS(I) = (I)*8_IB4
+   CELL_TYPE(I) = 11_IB4
+ENDDO
+
+IF (VTK_BINARY) THEN
+   CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii')
+   CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii')
+ELSE
+   CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii')
+   CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii')
+ENDIF
+
+DEALLOCATE(OFFSETS)
+DEALLOCATE(CELL_TYPE)
+DEALLOCATE(CONNECT)
+DEALLOCATE(X_PTS)
+DEALLOCATE(Y_PTS)
+DEALLOCATE(Z_PTS)
+         
+ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY
+         
+
+SUBROUTINE ENCODE_BITS(BITS, PADD, CODE)
+!< Encode a bits stream (must be multiple of 24 bits) into base64 charcaters code (of length multiple of 4).
+!<
+!< The bits stream are encoded in chunks of 24 bits as the following example (in little endian order)
+!<```
+!< +--first octet--+-second octet--+--third octet--+
+!< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
+!< +-----------+---+-------+-------+---+-----------+
+!< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|
+!< +--1.index--+--2.index--+--3.index--+--4.index--+
+!<```
+!< @note The 4 indexes are stored into 4 elements 8 bits array, thus 2 bits of each array element are not used.
+!<
+!< @note The number of paddings must be computed outside this procedure, into the calling scope.
+!<
+!< @warning This procedure is the backend of encoding, thus it must be never called outside the module.
+integer(I1P), intent(in)  :: bits(1:)  !< Bits to be encoded.
+integer(I4P), intent(in)  :: padd      !< Number of padding characters ('=').
+character(*), intent(out) :: code      !< Characters code.
+integer(I1P)              :: sixb(1:4) !< 6 bits slices (stored into 8 bits integer) of 24 bits input.
+integer(I8P)              :: c         !< Counter.
+integer(I8P)              :: e         !< Counter.
+integer(I8P)              :: Nb        !< Length of bits array.
+character(64) :: base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" !< Base64 alphabet.
+
+Nb=size(bits,dim=1,kind=I8P)
+c = 1_I8P
+do e=1_I8P,Nb,3_I8P ! loop over array elements: 3 bytes (24 bits) scanning
+  sixb = 0_I1P
+     call mvbits(bits(e  ),2,6,sixb(1),0)
+     call mvbits(bits(e  ),0,2,sixb(2),4)
+  if (e+1<=Nb) then
+     call mvbits(bits(e+1),4,4,sixb(2),0)
+     call mvbits(bits(e+1),0,4,sixb(3),2)
+  endif
+  if (e+2<=Nb) then
+     call mvbits(bits(e+2),6,2,sixb(3),0)
+     call mvbits(bits(e+2),0,6,sixb(4),0)
+  endif
+  sixb = sixb + 1_I1P
+  code(c  :c  ) = base64(sixb(1):sixb(1))
+  code(c+1:c+1) = base64(sixb(2):sixb(2))
+  code(c+2:c+2) = base64(sixb(3):sixb(3))
+  code(c+3:c+3) = base64(sixb(4):sixb(4))
+  c = c + 4_I8P
+enddo
+if (padd>0) code(len(code)-padd+1:)=repeat('=',padd)
+endsubroutine encode_bits
+
 END MODULE VTK
 
 !FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE)

From f47276a674ddfcf29d5570f4078a00711ce86dbd Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 2 Jan 2024 13:07:58 -0500
Subject: [PATCH 20/31] revert storing files in results/ directory

---
 Source/c_mkdir.c   | 11 -----------
 Source/dump.f90    | 12 +++++-------
 Source/f_mkdir.f90 | 12 ------------
 3 files changed, 5 insertions(+), 30 deletions(-)
 delete mode 100644 Source/c_mkdir.c
 delete mode 100644 Source/f_mkdir.f90

diff --git a/Source/c_mkdir.c b/Source/c_mkdir.c
deleted file mode 100644
index de730241478..00000000000
--- a/Source/c_mkdir.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-
-void c_mkdir(const char*directory){
-  struct stat st = {0};
-  if (stat(directory, &st) == -1) {
-      mkdir(directory, 0700);
-  }
-}
-
diff --git a/Source/dump.f90 b/Source/dump.f90
index f81e5ff0d0e..d5f0e44a2c2 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -22,9 +22,6 @@ MODULE DUMP
 USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
                 FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER
 
-USE F_MKDIR, ONLY : C_MKDIR
-USE ISO_C_BINDING
-
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
@@ -112,7 +109,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN
-   CALL C_MKDIR("./results"//char(0))
+   !CALL C_MKDIR("./results"//char(0))
    CALL DUMP_SMOKE3D(T,DT,NM,0)
    DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1)
       SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1
@@ -121,7 +118,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN
-   CALL C_MKDIR("./results"//char(0))
+   !CALL C_MKDIR("./results"//char(0))
    CALL DUMP_SLCF(T,DT,NM,0)
    DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1)
       SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1
@@ -4366,7 +4363,8 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
-      WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
+      WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
+      !WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
       !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1
       ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1))
       DO I = 0, IBAR
@@ -6035,7 +6033,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM = ITM+1
          ITM1 = 0
       ENDIF
-      WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu'
+      WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu'
       IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
          CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
          CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM))
diff --git a/Source/f_mkdir.f90 b/Source/f_mkdir.f90
deleted file mode 100644
index 5ee69b0f6e6..00000000000
--- a/Source/f_mkdir.f90
+++ /dev/null
@@ -1,12 +0,0 @@
-MODULE F_MKDIR
-
-  USE ISO_C_BINDING
-
-  INTERFACE
-    SUBROUTINE C_MKDIR(DIRECTORY) BIND(C)
-      USE ISO_C_BINDING
-      CHARACTER(KIND=C_CHAR),INTENT(IN) :: DIRECTORY(*)
-    END SUBROUTINE
-  END INTERFACE
-
-END MODULE

From 1c2b1ea6c936aea0284e75f4bd7ceb14921f546a Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Tue, 2 Jan 2024 17:16:40 -0500
Subject: [PATCH 21/31] add vtkfortran module

---
 Build/makefile  |    22 +-
 Source/dump.f90 |   140 +-
 Source/prec.f90 |     2 +-
 Source/vtk.f90  |   526 --
 Source/vtkf.f90 | 19593 ++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 19719 insertions(+), 564 deletions(-)
 delete mode 100644 Source/vtk.f90
 create mode 100644 Source/vtkf.f90

diff --git a/Build/makefile b/Build/makefile
index 9532c762a04..8f7de5a076e 100644
--- a/Build/makefile
+++ b/Build/makefile
@@ -117,7 +117,7 @@ endif # MKLROOT test
 
 obj_mpi = prec.o cons.o prop.o devc.o type.o data.o mesh.o func.o gsmv.o smvv.o rcal.o turb.o soot.o \
           pois.o geom.o ccib.o radi.o part.o vege.o ctrl.o hvac.o mass.o \
-          wall.o fire.o velo.o pres.o init.o dump.o read.o divg.o main.o
+          wall.o fire.o velo.o pres.o init.o vtkf.o dump.o read.o divg.o main.o
 
 objwin_mpi = $(obj_mpi:.o=.obj)
 
@@ -139,7 +139,7 @@ setup_win:
 	$(FCOMPL) -c $(FFLAGS) $<
 .f90.obj:
 	$(FCOMPL) -c $(FFLAGS) $<
-
+	   
 # Files which have OpenMP compiler directives are compiled using the FOPENMPFLAG and can be enabled/disabled on a per-file basis.
 
 divg.o: FFLAGS += $(FOPENMPFLAGS)
@@ -162,6 +162,12 @@ velo.obj: FFLAGS += $(FOPENMPFLAGS)
 radi.obj: FFLAGS += $(FOPENMPFLAGS)
 main.obj: FFLAGS += $(FOPENMPFLAGS)
 
+# Add flags for VTKF compilation
+#vtkf.o: FFLAGS += -D_R16P
+#vtkf.obj: FFLAGS += -D_R16P
+#vtkf.o: FFLAGS += -D_R_P_IS_R4P -D_ASCII_SUPPORTED
+
+
 # Windows Intel Fortran Compiler and Intel MPI
 #*** Note: the script, Build\Scripts\setup_intel_compilers.bat, must be run before running make with this target
 
@@ -227,7 +233,7 @@ impi_intel_win_openmp_db : setup_win $(objwin_mpi)
 
 # Linux Intel Fortran Compiler and Intel MPI
 
-impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -ipo -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT
+impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2  -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT
 impi_intel_linux : LFLAGSMKL = $(LFLAGSMKL_INTEL)
 impi_intel_linux : FCOMPL = mpiifort
 impi_intel_linux : obj = fds_impi_intel_linux
@@ -397,10 +403,11 @@ fire.o : func.o prec.o cons.o type.o mesh.o mass.o soot.o radi.o
 velo.o : func.o prec.o cons.o type.o mesh.o turb.o geom.o ccib.o
 pres.o : func.o prec.o cons.o type.o mesh.o pois.o velo.o geom.o ccib.o imkl.o
 init.o : func.o prec.o cons.o type.o mesh.o devc.o radi.o pois.o data.o pres.o geom.o
-dump.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o turb.o data.o radi.o soot.o geom.o ccib.o fire.o
+vtkf.o  : func.o prec.o cons.o type.o mesh.o data.o
+dump.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o turb.o data.o radi.o soot.o geom.o ccib.o fire.o vtkf.o
 read.o : func.o prec.o cons.o type.o mesh.o devc.o ctrl.o radi.o hvac.o data.o geom.o mass.o soot.o prop.o
 divg.o : func.o prec.o cons.o type.o mesh.o mass.o ccib.o
-main.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o mass.o divg.o velo.o wall.o fire.o radi.o part.o vege.o dump.o read.o init.o pres.o pois.o ctrl.o turb.o hvac.o data.o geom.o ccib.o soot.o prop.o
+main.o : func.o prec.o cons.o type.o mesh.o devc.o smvv.o mass.o divg.o velo.o wall.o fire.o radi.o part.o vege.o dump.o read.o init.o pres.o pois.o ctrl.o turb.o hvac.o data.o geom.o ccib.o soot.o prop.o vtkf.o
 
 prec.obj :
 imkl.obj :
@@ -430,10 +437,11 @@ fire.obj : func.obj prec.obj cons.obj type.obj mesh.obj mass.obj soot.obj radi.o
 velo.obj : func.obj prec.obj cons.obj type.obj mesh.obj turb.obj geom.obj ccib.obj
 pres.obj : func.obj prec.obj cons.obj type.obj mesh.obj pois.obj velo.obj geom.obj ccib.obj imkl.obj
 init.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj pois.obj data.obj pres.obj geom.obj
-dump.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj turb.obj data.obj radi.obj soot.obj geom.obj ccib.obj fire.obj
+vtkf.obj  : func.obj prec.obj cons.obj type.obj mesh.obj data.obj
+dump.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj turb.obj data.obj radi.obj soot.obj geom.obj ccib.obj fire.obj vtkf.obj
 read.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj ctrl.obj radi.obj hvac.obj data.obj geom.obj mass.obj soot.obj prop.obj
 divg.obj : func.obj prec.obj cons.obj type.obj mesh.obj mass.obj ccib.obj
-main.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj mass.obj divg.obj velo.obj wall.obj fire.obj radi.obj part.obj vege.obj dump.obj read.obj init.obj pres.obj pois.obj ctrl.obj turb.obj hvac.obj data.obj geom.obj ccib.obj soot.obj prop.obj
+main.obj : func.obj prec.obj cons.obj type.obj mesh.obj devc.obj smvv.obj mass.obj divg.obj velo.obj wall.obj fire.obj radi.obj part.obj vege.obj dump.obj read.obj init.obj pres.obj pois.obj ctrl.obj turb.obj hvac.obj data.obj geom.obj ccib.obj soot.obj prop.obj vtkf.obj
 
 #*** Clean Target to remove Object and Module files ***
 
diff --git a/Source/dump.f90 b/Source/dump.f90
index d5f0e44a2c2..4ac629df9f6 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,8 +19,9 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
-USE VTK, ONLY : INITIALIZE_VTK, WRITE_VTK_SLICE_GEOMETRY, WRITE_VTK_SLICE_CELLS, WRITE_VTK_SLICE_DATA,&
-                FINALIZE_VTK,WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER
+USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,&
+                WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
+USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
@@ -109,7 +110,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SM3D_CLOCK(SM3D_COUNTER(NM)) .AND. SMOKE3D) THEN
-   !CALL C_MKDIR("./results"//char(0))
    CALL DUMP_SMOKE3D(T,DT,NM,0)
    DO WHILE(SM3D_COUNTER(NM)<SIZE(SM3D_CLOCK)-1)
       SM3D_COUNTER(NM) = SM3D_COUNTER(NM) + 1
@@ -118,7 +118,6 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ENDIF
 
 IF (T>=SLCF_CLOCK(SLCF_COUNTER(NM))) THEN
-   !CALL C_MKDIR("./results"//char(0))
    CALL DUMP_SLCF(T,DT,NM,0)
    DO WHILE(SLCF_COUNTER(NM)<SIZE(SLCF_CLOCK)-1)
       SLCF_COUNTER(NM) = SLCF_COUNTER(NM) + 1
@@ -137,7 +136,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ! VTK 3-D slices
 IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
    IF (NM .EQ. 1) THEN
-      CALL WRITE_VTK_SLICE_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+      CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES,'PUnstructuredGrid')
    ENDIF
    CALL DUMP_SLCF(T,DT,NM,3)
    DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1)
@@ -1436,7 +1435,7 @@ SUBROUTINE WRITE_STL_FILE
    CHARACTER(LEN=80) :: TITLE
    REAL(FB) :: VERTICES(8,3), XB(6)
    REAL(FB) :: GEOM_VERTICES(3,3)
-   INTEGER(IB4) :: COLOR(3), ONE
+   INTEGER(IB8) :: COLOR(3), ONE
    INTEGER(IB32) :: NUM_FACETS
 
    COLOR = (/0,0,0/)
@@ -4281,13 +4280,20 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
 USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE
 REAL(EB), INTENT(IN) :: T,DT
 INTEGER,  INTENT(IN) :: NM,IFRMT
-INTEGER  :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1
+INTEGER  :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP
 REAL(FB) :: DXX,STIME
 REAL(EB), POINTER, DIMENSION(:,:,:) :: FF
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
 REAL(EB) :: FR_C,TT
 TYPE(SMOKE3D_TYPE), POINTER :: S3
 LOGICAL :: SMV_OUT,VTK_OUT
+TYPE(VTK_FILE)     :: A_VTK_FILE                    ! A VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+REAL(FB) :: FACTOR,VAL_FDS,VAL_SMV,TEMP_MIN
 
 CALL POINT_TO_MESH(NM)
 
@@ -4378,23 +4384,77 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
          ENDDO
       ENDDO
       IF (N .EQ. 1) THEN
-         CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
-         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), LU_SMOKE3D_VTK(NM))
+         !CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
+         !CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM),  &
+         !                                  NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+         !CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+         !
+         IF (VTK_BINARY) THEN
+            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+         ELSE
+            VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+         ENDIF ! do not change capitalization on mesh topology
+         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), &
+                                           NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN')
+         CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+         
       ENDIF
-      IF (VTK_BINARY) THEN
-         CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
-                                   QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+      ALLOCATE(QQ_PACK_INT(IBP1*JBP1*KBP1))
+      IF (S3%DISPLAY_TYPE=='GAS') THEN
+
+         FACTOR=-REAL(S3%MASS_EXTINCTION_COEFFICIENT,FB)*DXX
+         DO I=1,NP
+            VAL_FDS = MAX(0.0_FB,QQ_PACK(I))
+            VAL_SMV = 254*(1.0_FB-EXP(FACTOR*VAL_FDS))
+            QQ_PACK_INT(I) = NINT(VAL_SMV)
+         ENDDO
+
+      ELSEIF (S3%DISPLAY_TYPE=='FIRE') THEN
+
+         DO I=1,NP
+            VAL_FDS = MIN(HRRPUV_MAX_SMV,MAX(0._FB,QQ_PACK(I)))
+            VAL_SMV = 254*(VAL_FDS/HRRPUV_MAX_SMV)
+            QQ_PACK_INT(I) = NINT(VAL_SMV)
+         ENDDO
+
+      ELSEIF (S3%DISPLAY_TYPE=='TEMPERATURE') THEN
+
+         TEMP_MIN = REAL(TMPA-TMPM,FB)
+         DO I=1,NP
+            VAL_FDS = MIN(TEMP_MAX_SMV,MAX(TEMP_MIN,QQ_PACK(I)))
+            VAL_SMV = 254*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN))
+            QQ_PACK_INT(I) = NINT(VAL_SMV)
+         ENDDO
+
       ELSE
-         CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
-                                   QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+         DO I=1,NP
+            QQ_PACK_INT(I) = NINT(QQ_PACK(I))
+         ENDDO
       ENDIF
+      
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=S3%SMOKEVIEW_LABEL(1:30), X=QQ_PACK_INT)
+      !IF (VTK_BINARY) THEN
+      !   CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
+      !                             QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+      !ELSE
+      !   CALL WRITE_VTK_SLICE_DATA(LU_SMOKE3D_VTK(NM), FN_SMOKE3D_VTK(NM),&
+      !                             QQ_PACK, S3%SMOKEVIEW_LABEL(1:30), 'ascii')
+      !ENDIF
+      DEALLOCATE(QQ_PACK_INT)
    ENDIF
    DEALLOCATE(QQ_PACK)
 
 ENDDO DATA_FILE_LOOP
 
 IF (VTK_OUT) THEN
-   CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
+   !CALL FINALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+   VTK_ERROR = A_VTK_FILE%FINALIZE()
 ENDIF
 
 END SUBROUTINE DUMP_SMOKE3D
@@ -5872,11 +5932,14 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 REAL(FB) :: SLICE_MIN, SLICE_MAX, DSLICE
 INTEGER :: NX, NY, NZ, NC, NP
 INTEGER :: IFACT, JFACT, KFACT
-REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS
-INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
-INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
 REAL(FB) :: UVEL, VVEL, WVEL, VEL, PLOT3D_MIN, PLOT3D_MAX
 INTEGER :: IERROR
+TYPE(VTK_FILE)     :: A_VTK_FILE                    ! A VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
 LOGICAL :: VTK_INITIALIZED
 
 ! Return if there are no slices to process and this is not a Plot3D dump
@@ -6034,10 +6097,23 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          ITM1 = 0
       ENDIF
       WRITE(FN_SL3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',NM,'_',ITM,ITM1,'.vtu'
-      IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
-         CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
-         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM))
-      ENDIF
+      IF (VTK_BINARY) THEN
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+      ELSE
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+      ENDIF ! do not change capitalization on mesh topology
+      CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), &
+                                        NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN')
+      CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+      
+      !IF (SL%SLICETYPE=='STRUCTURED') THEN ! write out slice file using original slice file format
+      !   CALL INITIALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
+      !   CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), LU_SL3D_VTK(NM))
+      !ENDIF
       VTK_INITIALIZED=.TRUE.
    ENDIF
 
@@ -6330,13 +6406,14 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
                ENDDO
             ENDDO
             
-            IF (VTK_BINARY) THEN
-               CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
-                                         QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
-            ELSE
-               CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
-                                         QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
-            ENDIF
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
+            !IF (VTK_BINARY) THEN
+            !   CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
+            !                             QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            !ELSE
+            !   CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
+            !                             QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
+            !ENDIF
             
             DEALLOCATE(QQ_PACK)
          ENDIF
@@ -6347,7 +6424,10 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
 
 IF (VTK3D) THEN
    ! finish after writing all pieces
-   CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
+   !CALL FINALIZE_VTK(LU_SL3D_VTK(NM),FN_SL3D_VTK(NM),'UnstructuredGrid')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE')
+   VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+   VTK_ERROR = A_VTK_FILE%FINALIZE()
 ENDIF
 
 ! Write out the PLOT3D ``q'' file
diff --git a/Source/prec.f90 b/Source/prec.f90
index 10791f7d953..17695231bc6 100644
--- a/Source/prec.f90
+++ b/Source/prec.f90
@@ -6,7 +6,7 @@ MODULE PRECISION_PARAMETERS
 
 INTEGER, PARAMETER :: FB = SELECTED_REAL_KIND(6)     !< Precision of "Four Byte" reals
 INTEGER, PARAMETER :: EB = SELECTED_REAL_KIND(12)    !< Precision of "Eight Byte" reals
-INTEGER, PARAMETER :: IB4 = SELECTED_INT_KIND(1)     !< Precision of "One Byte" ints
+INTEGER, PARAMETER :: IB8 = SELECTED_INT_KIND(2)     !< Precision of "One Byte" ints
 INTEGER, PARAMETER :: IB16 = SELECTED_INT_KIND(3)    !< Precision of "Two Byte" ints
 INTEGER, PARAMETER :: IB32 = SELECTED_INT_KIND(6)    !< Precision of "Four Byte" ints
 INTEGER, PARAMETER :: QB = SELECTED_REAL_KIND(33,4931) !< Precision of "Sixteen Byte" reals
diff --git a/Source/vtk.f90 b/Source/vtk.f90
deleted file mode 100644
index 3af31662e85..00000000000
--- a/Source/vtk.f90
+++ /dev/null
@@ -1,526 +0,0 @@
-!> \brief Routines for handling vtk output
-
-MODULE VTK
-
-USE MESH_VARIABLES
-USE GLOBAL_CONSTANTS
-USE MESH_POINTERS
-USE OUTPUT_DATA
-
-IMPLICIT NONE (TYPE,EXTERNAL)
-PRIVATE
-
-PUBLIC INITIALIZE_VTK,WRITE_VTK_SLICE_GEOMETRY,WRITE_VTK_SLICE_CELLS,WRITE_VTK_SLICE_DATA,FINALIZE_VTK,&
-       WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,WRITE_VTK_SM3D_WRAPPER
-
-CONTAINS
-
-SUBROUTINE INITIALIZE_VTK(LU,FN,MESH_TOPOLOGY)
-
-INTEGER, INTENT(IN) :: LU
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN
-OPEN(LU,FILE=FN,FORM='FORMATTED')
-WRITE(LU,'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
-WRITE(LU,'(A,A,A)',ADVANCE='YES') '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
-WRITE(LU,'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),'>'
-CLOSE(LU)
-END SUBROUTINE INITIALIZE_VTK
-
-SUBROUTINE WRITE_VTK_SLICE_GEOMETRY(LU, FN, NP, NC, X_PTS, Y_PTS, Z_PTS, FORMAT)
-
-INTEGER, INTENT(IN) :: LU, NC, NP
-REAL(FB), DIMENSION(:), INTENT(IN) :: X_PTS, Y_PTS, Z_PTS
-CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT
-INTEGER :: I
-
-OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU,'(A,I0,A,I0,A)',ADVANCE='YES') '    <Piece NumberOfPoints="',NP,'" NumberOfCells="',NC,'">'
-WRITE(LU,'(A)',ADVANCE='YES') '      <Points>'
-WRITE(LU,'(A,A,A)',ADVANCE='YES') &
-   '        <DataArray type="Float32" NumberOfComponents="3" Name="Points" format="',FORMAT,'">'
-
-WRITE(LU,'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .eq. 'ascii') THEN
-   DO I=1,NP
-      WRITE(LU,'(E15.8,A,E15.8,A,E15.8,A)',ADVANCE='NO') X_PTS(I),' ',Y_PTS(I),' ',Z_PTS(I),' '
-   ENDDO
-ENDIF
-WRITE(LU,'(A)',ADVANCE='YES') ' '
-WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
-WRITE(LU,'(A)',ADVANCE='YES') '      </Points>'
-CLOSE(LU)
-
-END SUBROUTINE WRITE_VTK_SLICE_GEOMETRY
-
-SUBROUTINE WRITE_VTK_SLICE_CELLS(LU, FN, CONNECT, OFFSETS, CELL_TYPE, FORMAT)
-
-INTEGER, INTENT(IN) :: LU
-INTEGER, DIMENSION(:), INTENT(IN) :: CONNECT, OFFSETS
-INTEGER(IB4), DIMENSION(:), INTENT(IN) :: CELL_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: FN, FORMAT
-INTEGER :: I
-
-! Open cells section
-OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU,'(A)',ADVANCE='YES') '      <Cells>'
-
-! Write connectivity
-WRITE(LU,'(A,A,A)',ADVANCE='YES') &
-   '        <DataArray type="Int32" NumberOfComponents="1" Name="connectivity" format="',FORMAT,'">'
-
-WRITE(LU,'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
-   DO I=1,SIZE(CONNECT)
-      WRITE(LU,'(I0,A)',ADVANCE='NO') CONNECT(I), ' '
-   ENDDO
-ENDIF
-WRITE(LU,'(A)',ADVANCE='YES') ' '
-WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
-
-! Write offsets
-WRITE(LU,'(A,A,A)',ADVANCE='YES') &
-   '        <DataArray type="Int32" NumberOfComponents="1" Name="offsets" format="',FORMAT,'">'
-
-WRITE(LU,'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
-   DO I=1,SIZE(OFFSETS)
-      WRITE(LU,'(I0,A)',ADVANCE='NO') OFFSETS(I), ' '
-   ENDDO
-ENDIF
-WRITE(LU,'(A)',ADVANCE='YES') ' '
-WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
-
-! Write cell types
-WRITE(LU,'(A,A,A)',ADVANCE='YES') &
-   '        <DataArray type="Int8" NumberOfComponents="1" Name="types" format="',FORMAT,'">'
-
-WRITE(LU,'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
-   DO I=1,SIZE(CELL_TYPE)
-      WRITE(LU,'(I0,A)',ADVANCE='NO') CELL_TYPE(I), ' '
-   ENDDO
-ENDIF
-WRITE(LU,'(A)',ADVANCE='YES') ' '
-WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
-
-! Close cell section
-WRITE(LU,'(A)',ADVANCE='YES') '      </Cells>'
-
-! Open point data section
-WRITE(LU,'(A)',ADVANCE='YES') '      <PointData>'
-
-CLOSE(LU)
-
-END SUBROUTINE WRITE_VTK_SLICE_CELLS
-
-SUBROUTINE WRITE_VTK_SLICE_DATA(LU, FN, DATA, DATA_NAME, FORMAT)
-
-INTEGER, INTENT(IN) :: LU
-CHARACTER(LEN=*), INTENT(IN) :: FORMAT, DATA_NAME, FN
-CHARACTER(LEN=:), ALLOCATABLE :: CODE
-REAL(FB), DIMENSION(:) :: DATA
-INTEGER :: I, NBITS_DATA, NSTRINGS_DATA
-CHARACTER(LEN=:), ALLOCATABLE :: BIT_DATA
-
-!real(R16P),                    intent(in)  :: n       !< Number to be encoded.
-integer(I1P),     allocatable              :: nI1P(:) !< One byte integer array containing n.
-integer(I4P)                               :: padd    !< Number of padding characters ('=').
-
-integer(I4P) :: BYR16P = 2_I1P
-
-
-
-
-! Open data section
-OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-
-! Write data
-WRITE(LU,'(A,A,A,A,A)',ADVANCE='YES') &
-   '        <DataArray type="Float32" NumberOfComponents="1" Name="',&
-  TRIM(DATA_NAME),'" format="',FORMAT,'">'
-
-WRITE(LU,'(A)',ADVANCE='NO') '          '
-IF (TRIM(ADJUSTL(FORMAT)) .EQ. 'ascii') THEN
-   DO I=1,SIZE(DATA)
-      WRITE(LU,'(E15.8,A)',ADVANCE='NO') DATA(I), ' '
-   ENDDO
-ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'binary') THEN
-   CLOSE(LU)
-   OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
-   !NBITS_DATA = SIZE(DATA) * SIZEOF(FB)*2
-   !NSTRINGS_DATA = INT(FLOAT(NBITS_DATA)/3+0.9)
-   
-   allocate(nI1P(1:((BYR16P+2)/3)*3)) ; nI1P = 0_I1P
-   code = repeat(' ',((BYR16P+2)/3)*4)
-   nI1P = transfer(DATA,nI1P)
-   padd = mod((BYR16P),3) ; if (padd>0_I4P) padd = 3_I4P - padd
-
-
-   
-   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
-   
-   WRITE(*,*) "SIZES", SIZE(DATA), NBITS_DATA
-   WRITE(*,*) PADD
-   WRITE(*,*) CODE
-   !ALLOCATE(CHARACTER(LEN=NBITS_DATA) :: BIT_DATA)
-   !WRITE(BIT_DATA,'(B64)') DATA
-   !WRITE(*,*) BIT_DATA
-   !DEALLOCATE(BIT_DATA)
-   !DO I=0,NSTRINGS_DATA
-   !   STRINGBITS = DATA(I*6:(I+1)*6)
-   !   WRITE(*,*), "DATA ", I, " ", STRINGBITS
-   !ENDDO
-   !WRITE(LU_SL3D_VTK(NM)) NBITS_DATA  , (DATA(I),I=1,SIZE(DATA))
-   CLOSE(LU)
-   OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-   !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA)
-   !WRITE(LU_SL3D_VTK(NM)) CODE
-ELSEIF (TRIM(ADJUSTL(FORMAT)) .EQ. 'appended') THEN
-   CLOSE(LU)
-   OPEN(LU,FILE=FN,FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
-   NBITS_DATA = SIZE(DATA) * SIZEOF(FB)
-   WRITE(LU) NBITS_DATA  , (DATA(I),I=1,SIZE(DATA))
-   CLOSE(LU)
-   OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-   !CODE=ENCODE_ASCII_DATAARRAY1_RANK1_FB(DATA)
-   !WRITE(LU_SL3D_VTK(NM)) CODE
-ENDIF
-WRITE(LU,'(A)',ADVANCE='YES') ' '
-
-! Close data section
-WRITE(LU,'(A)',ADVANCE='YES') '        </DataArray>'
-CLOSE(LU)
-
-END SUBROUTINE WRITE_VTK_SLICE_DATA
-
-SUBROUTINE FINALIZE_VTK(LU,FN,MESH_TOPOLOGY)
-
-INTEGER, INTENT(IN) :: LU
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY,FN
-
-! Close VTK file
-OPEN(LU,FILE=FN,FORM='FORMATTED',STATUS='OLD',POSITION='APPEND')
-WRITE(LU,'(A)',ADVANCE='YES') '      </PointData>'
-WRITE(LU,'(A)',ADVANCE='YES') '    </Piece>'
-WRITE(LU,'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
-WRITE(LU,'(A)',ADVANCE='YES') '</VTKFile>'
-
-CLOSE(LU)
-END SUBROUTINE FINALIZE_VTK
-
-SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
-INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
-REAL(EB), INTENT(IN) :: T
-TYPE (SLICE_TYPE), POINTER :: SL
-INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
-REAL(FB) :: STIME
-REAL(EB) :: TT
-CHARACTER(200) :: TMP_FILE
-
-! Generate filename
-STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
-TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
-ITM  = INT(TT)
-ITM1 = NINT(ABS(TT-ITM)*100)
-IF (ITM1==100) THEN
-   ITM = ITM+1
-   ITM1 = 0
-ENDIF
-WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu'
-
-! First part of header before quantities
-OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED')
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
-   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
-
-! Add PointData arrays
-NQT = MESHES(1)%N_SLCF
-QUANTITY_LOOP2: DO IQ=1,NQT
-   SL => SLICE(IQ)
-   I1  = SL%I1
-   I2  = SL%I2
-   J1  = SL%J1
-   J2  = SL%J2
-   K1  = SL%K1
-   K2  = SL%K2
-   IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format='
-   IF (VTK_BINARY) THEN
-      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-   ELSE
-      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-   ENDIF
-ENDDO QUANTITY_LOOP2
-
-! Close PointData
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
-
-! Add Point arrays
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
-IF (VTK_BINARY) THEN
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-ELSE
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-ENDIF
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
-
-! Add CellData
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
-
-! Write pieces
-DO I=1,NMESHES
-   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu'
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
-ENDDO
-
-! Finalize file
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
-CLOSE(LU_SL3D_VTK(NMESHES+1))
-END SUBROUTINE WRITE_VTK_SLICE_WRAPPER
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
-INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
-REAL(EB), INTENT(IN) :: T
-TYPE (SLICE_TYPE), POINTER :: SL
-INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1,N
-REAL(FB) :: STIME
-REAL(EB) :: TT
-CHARACTER(200) :: TMP_FILE
-TYPE(SMOKE3D_TYPE), POINTER :: S3
-
-! Generate filename
-STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
-TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
-ITM  = INT(TT)
-ITM1 = NINT(ABS(TT-ITM)*100)
-IF (ITM1==100) THEN
-   ITM = ITM+1
-   ITM1 = 0
-ENDIF
-WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu'
-
-! First part of header before quantities
-OPEN(LU_SMOKE3D_VTK(NMESHES+1),FILE=FN_SMOKE3D_VTK(NMESHES+1),FORM='FORMATTED')
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
-   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
-
-! Add PointData arrays
-DATA_FILE_LOOP2: DO N=1,N_SMOKE3D
-
-   S3 => SMOKE3D_FILE(N)
-   WRITE(*,*) "SMOKE3D QUANTITY", S3%SMOKEVIEW_LABEL(1:30)
-   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
-   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(S3%SMOKEVIEW_LABEL(1:30)),'" format='
-   IF (VTK_BINARY) THEN
-      WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-   ELSE
-      WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-   ENDIF
-ENDDO DATA_FILE_LOOP2
-
-! Close PointData
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
-
-! Add Point arrays
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
-IF (VTK_BINARY) THEN
-   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-ELSE
-   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-ENDIF
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
-
-! Add CellData
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
-
-! Write pieces
-DO I=1,NMESHES
-   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu'
-   WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
-ENDDO
-
-! Finalize file
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
-WRITE(LU_SMOKE3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
-CLOSE(LU_SMOKE3D_VTK(NMESHES+1))
-END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
-
-
-
-SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, LU)
-
-INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT
-REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK, X_PTS, Y_PTS, Z_PTS
-INTEGER, ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
-INTEGER(IB4), ALLOCATABLE, DIMENSION(:) :: CELL_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN
-INTEGER, INTENT(IN) :: NM, LU
-
-NX = SIZE(MESHES(NM)%X)
-NY = SIZE(MESHES(NM)%Y)
-NZ = SIZE(MESHES(NM)%Z)
-
-NP = NX*NY*NZ
-NC = (NX-1)*(NY-1)*(NZ-1)
-
-! Fill point data
-ALLOCATE(X_PTS(NP))
-ALLOCATE(Y_PTS(NP))
-ALLOCATE(Z_PTS(NP))
-IFACT = 1
-DO K = 0, NZ-1
-   DO J = 0, NY-1
-      DO I = 0, NX-1
-         X_PTS(IFACT)=MESHES(NM)%X(I)
-         Y_PTS(IFACT)=MESHES(NM)%Y(J)
-         Z_PTS(IFACT)=MESHES(NM)%Z(K)
-         IFACT = IFACT + 1
-      ENDDO
-   ENDDO
-ENDDO
-
-! Fill cell data
-ALLOCATE(CONNECT(NC*8))
-DO I = 1, NX-1
-   IFACT = (I-1)
-   DO J = 1, NY-1
-      JFACT = (J-1)*(NX-1)
-      DO K = 1, NZ-1
-         KFACT = (K - 1)*(NY-1)*(NX-1)
-         CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1
-         CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I
-         CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1
-         CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I
-         CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1
-         CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I
-         CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1
-         CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I
-      ENDDO
-   ENDDO
-ENDDO
-
-ALLOCATE(OFFSETS(NC))
-ALLOCATE(CELL_TYPE(NC))
-
-DO I=1,NC
-   OFFSETS(I) = (I)*8_IB4
-   CELL_TYPE(I) = 11_IB4
-ENDDO
-
-IF (VTK_BINARY) THEN
-   CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii')
-   CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii')
-ELSE
-   CALL WRITE_VTK_SLICE_GEOMETRY(LU,FN,NP,NC,X_PTS,Y_PTS,Z_PTS,'ascii')
-   CALL WRITE_VTK_SLICE_CELLS(LU,FN,CONNECT,OFFSETS,CELL_TYPE,'ascii')
-ENDIF
-
-DEALLOCATE(OFFSETS)
-DEALLOCATE(CELL_TYPE)
-DEALLOCATE(CONNECT)
-DEALLOCATE(X_PTS)
-DEALLOCATE(Y_PTS)
-DEALLOCATE(Z_PTS)
-         
-ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY
-         
-
-SUBROUTINE ENCODE_BITS(BITS, PADD, CODE)
-!< Encode a bits stream (must be multiple of 24 bits) into base64 charcaters code (of length multiple of 4).
-!<
-!< The bits stream are encoded in chunks of 24 bits as the following example (in little endian order)
-!<```
-!< +--first octet--+-second octet--+--third octet--+
-!< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
-!< +-----------+---+-------+-------+---+-----------+
-!< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|
-!< +--1.index--+--2.index--+--3.index--+--4.index--+
-!<```
-!< @note The 4 indexes are stored into 4 elements 8 bits array, thus 2 bits of each array element are not used.
-!<
-!< @note The number of paddings must be computed outside this procedure, into the calling scope.
-!<
-!< @warning This procedure is the backend of encoding, thus it must be never called outside the module.
-integer(I1P), intent(in)  :: bits(1:)  !< Bits to be encoded.
-integer(I4P), intent(in)  :: padd      !< Number of padding characters ('=').
-character(*), intent(out) :: code      !< Characters code.
-integer(I1P)              :: sixb(1:4) !< 6 bits slices (stored into 8 bits integer) of 24 bits input.
-integer(I8P)              :: c         !< Counter.
-integer(I8P)              :: e         !< Counter.
-integer(I8P)              :: Nb        !< Length of bits array.
-character(64) :: base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" !< Base64 alphabet.
-
-Nb=size(bits,dim=1,kind=I8P)
-c = 1_I8P
-do e=1_I8P,Nb,3_I8P ! loop over array elements: 3 bytes (24 bits) scanning
-  sixb = 0_I1P
-     call mvbits(bits(e  ),2,6,sixb(1),0)
-     call mvbits(bits(e  ),0,2,sixb(2),4)
-  if (e+1<=Nb) then
-     call mvbits(bits(e+1),4,4,sixb(2),0)
-     call mvbits(bits(e+1),0,4,sixb(3),2)
-  endif
-  if (e+2<=Nb) then
-     call mvbits(bits(e+2),6,2,sixb(3),0)
-     call mvbits(bits(e+2),0,6,sixb(4),0)
-  endif
-  sixb = sixb + 1_I1P
-  code(c  :c  ) = base64(sixb(1):sixb(1))
-  code(c+1:c+1) = base64(sixb(2):sixb(2))
-  code(c+2:c+2) = base64(sixb(3):sixb(3))
-  code(c+3:c+3) = base64(sixb(4):sixb(4))
-  c = c + 4_I8P
-enddo
-if (padd>0) code(len(code)-padd+1:)=repeat('=',padd)
-endsubroutine encode_bits
-
-END MODULE VTK
-
-!FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB(X) RESULT(CODE)
-!!< Encode (Base64) a dataarray with 1 components of rank 1 (FB).
-!REAL(FB), INTENT(IN)          :: X(1:) !< Data variable.
-!CHARACTER(len=:), ALLOCATABLE :: CODE  !< Encoded base64 dataarray.
-!INTEGER(IB16)                  :: N     !< Counter.
-!INTEGER(IB16)                  :: L     !< Length
-!INTEGER(IB16)                  :: SP    !< String pointer
-!INTEGER(IB16)                  :: SIZE_N!< Dimension size
-!
-!SIZE_N = SIZE(X,DIM=1)
-!L = DI2P+1
-!SP = 0
-!CODE = REPEAT(' ',L*SIZE_N)
-!DO N = 1,SIZE_N
-!    CODE(SP+1:SP+L) = STR(N=X(N))
-!    SP = SP + L
-!ENDDO
-!ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_FB
-!
-!END MODULE VTK
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
new file mode 100644
index 00000000000..59943682cd5
--- /dev/null
+++ b/Source/vtkf.f90
@@ -0,0 +1,19593 @@
+!< PENF GLOBAL PARAMETERS AND VARIABLES.
+
+MODULE PENF_GLOBAL_PARAMETERS_VARIABLES
+!< PENF GLOBAL PARAMETERS AND VARIABLES.
+!<
+!< @NOTE ALL MODULE DEFINED ENTITIES ARE PUBLIC.
+
+IMPLICIT NONE
+PUBLIC
+SAVE
+
+INTEGER, PARAMETER :: ENDIANL = 1 !< LITTLE ENDIAN PARAMETER.
+INTEGER, PARAMETER :: ENDIANB = 0 !< BIG ENDIAN PARAMETER.
+
+! PORTABLE KIND PARAMETERS
+#ifdef _ASCII_SUPPORTED
+INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII')     !< ASCII CHARACTER SET KIND.
+#else
+INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT')   !< ASCII CHARACTER SET KIND DEFINED AS DEFAULT SET.
+#endif
+#ifdef _UCS4_SUPPORTED
+INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND.
+#else
+INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('DEFAULT')   !< UNICODE CHARACTER SET KIND DEFINED AS DEFAULT SET.
+#endif
+#if defined _CK_IS_DEFAULT
+INTEGER, PARAMETER :: CK  = SELECTED_CHAR_KIND('DEFAULT')     !< DEFAULT KIND CHARACTER.
+#elif defined _CK_IS_ASCII
+INTEGER, PARAMETER :: CK  = ASCII                             !< DEFAULT KIND CHARACTER.
+#elif defined _CK_IS_UCS4
+INTEGER, PARAMETER :: CK  = UCS4                              !< DEFAULT KIND CHARACTER.
+#else
+INTEGER, PARAMETER :: CK  = SELECTED_CHAR_KIND('DEFAULT')     !< DEFAULT KIND CHARACTER.
+#endif
+
+INTEGER, PARAMETER :: R16P = SELECTED_REAL_KIND(33,4931) !< 33 DIGITS, RANGE \([10^{-4931}, 10^{+4931} - 1]\); 128 BITS.
+INTEGER, PARAMETER :: R8P  = SELECTED_REAL_KIND(15,307)  !< 15 DIGITS, RANGE \([10^{-307} , 10^{+307}  - 1]\); 64 BITS.
+INTEGER, PARAMETER :: R4P  = SELECTED_REAL_KIND(6,37)    !< 6  DIGITS, RANGE \([10^{-37}  , 10^{+37}   - 1]\); 32 BITS.
+#if defined _R_P_IS_R16P
+INTEGER, PARAMETER :: R_P  = R16P                        !< DEFAULT REAL PRECISION.
+#elif defined _R_P_IS_R8P
+INTEGER, PARAMETER :: R_P  = R8P                         !< DEFAULT REAL PRECISION.
+#elif defined _R_P_IS_R4P
+INTEGER, PARAMETER :: R_P  = R4P                         !< DEFAULT REAL PRECISION.
+#else
+INTEGER, PARAMETER :: R_P  = R8P                         !< DEFAULT REAL PRECISION.
+#endif
+
+INTEGER, PARAMETER :: I8P = SELECTED_INT_KIND(18) !< RANGE \([-2^{63},+2^{63} - 1]\), 19 DIGITS PLUS SIGN; 64 BITS.
+INTEGER, PARAMETER :: I4P = SELECTED_INT_KIND(9)  !< RANGE \([-2^{31},+2^{31} - 1]\), 10 DIGITS PLUS SIGN; 32 BITS.
+INTEGER, PARAMETER :: I2P = SELECTED_INT_KIND(4)  !< RANGE \([-2^{15},+2^{15} - 1]\), 5  DIGITS PLUS SIGN; 16 BITS.
+INTEGER, PARAMETER :: I1P = SELECTED_INT_KIND(2)  !< RANGE \([-2^{7} ,+2^{7}  - 1]\), 3  DIGITS PLUS SIGN; 8  BITS.
+INTEGER, PARAMETER :: I_P = I4P                   !< DEFAULT INTEGER PRECISION.
+
+! FORMAT PARAMETERS
+CHARACTER(*), PARAMETER :: FR16P = '(E42.33E4)' !< OUTPUT FORMAT FOR KIND=R16P REAL.
+CHARACTER(*), PARAMETER :: FR8P  = '(E23.15E3)' !< OUTPUT FORMAT FOR KIND=R8P REAL.
+CHARACTER(*), PARAMETER :: FR4P  = '(E13.6E2)'  !< OUTPUT FORMAT FOR KIND=R4P REAL.
+#if defined _R_P_IS_R16P
+CHARACTER(*), PARAMETER :: FR_P  = FR16P        !< OUTPUT FORMAT FOR KIND=R_P REAL.
+#elif defined _R_P_IS_R8P
+CHARACTER(*), PARAMETER :: FR_P  = FR8P         !< OUTPUT FORMAT FOR KIND=R_P REAL.
+#elif defined _R_P_IS_R4P
+CHARACTER(*), PARAMETER :: FR_P  = FR4P         !< OUTPUT FORMAT FOR KIND=R_P REAL.
+#else
+CHARACTER(*), PARAMETER :: FR_P  = FR8P         !< OUTPUT FORMAT FOR KIND=R_P REAL.
+#endif
+
+CHARACTER(*), PARAMETER :: FI8P   = '(I20)'    !< OUTPUT FORMAT FOR KIND=I8P INTEGER.
+CHARACTER(*), PARAMETER :: FI8PZP = '(I20.19)' !< OUTPUT FORMAT FOR KIND=I8P INTEGER WITH ZERO PREFIXING.
+CHARACTER(*), PARAMETER :: FI4P   = '(I11)'    !< OUTPUT FORMAT FOR KIND=I4P INTEGER.
+CHARACTER(*), PARAMETER :: FI4PZP = '(I11.10)' !< OUTPUT FORMAT FOR KIND=I4P INTEGER WITH ZERO PREFIXING.
+CHARACTER(*), PARAMETER :: FI2P   = '(I6)'     !< OUTPUT FORMAT FOR KIND=I2P INTEGER.
+CHARACTER(*), PARAMETER :: FI2PZP = '(I6.5)'   !< OUTPUT FORMAT FOR KIND=I2P INTEGER WITH ZERO PREFIXING.
+CHARACTER(*), PARAMETER :: FI1P   = '(I4)'     !< OUTPUT FORMAT FOR KIND=I1P INTEGER.
+CHARACTER(*), PARAMETER :: FI1PZP = '(I4.3)'   !< OUTPUT FORMAT FOR KIND=I1P INTEGER WITH ZERO PREFIXING.
+CHARACTER(*), PARAMETER :: FI_P   = FI4P       !< OUTPUT FORMAT FOR KIND=I_P INTEGER.
+CHARACTER(*), PARAMETER :: FI_PZP = FI4PZP     !< OUTPUT FORMAT FOR KIND=I_P INTEGER WITH ZERO PREFIXING.
+
+! LENGTH (NUMBER OF DIGITS) OF FORMATTED NUMBERS
+INTEGER, PARAMETER :: DR16P = 42    !< NUMBER OF DIGITS OF OUTPUT FORMAT FR16P.
+INTEGER, PARAMETER :: DR8P  = 23    !< NUMBER OF DIGITS OF OUTPUT FORMAT FR8P.
+INTEGER, PARAMETER :: DR4P  = 13    !< NUMBER OF DIGITS OF OUTPUT FORMAT FR4P.
+#if defined _R_P_IS_R16P
+INTEGER, PARAMETER :: DR_P  = DR16P !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P.
+#elif defined _R_P_IS_R8P
+INTEGER, PARAMETER :: DR_P  = DR8P  !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P.
+#elif defined _R_P_IS_R4P
+INTEGER, PARAMETER :: DR_P  = DR4P  !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P.
+#else
+INTEGER, PARAMETER :: DR_P  = DR8P  !< NUMBER OF DIGITS OF OUTPUT FORMAT FR_P.
+#endif
+
+INTEGER, PARAMETER :: DI8P  = 20   !< NUMBER OF DIGITS OF OUTPUT FORMAT I8P.
+INTEGER, PARAMETER :: DI4P  = 11   !< NUMBER OF DIGITS OF OUTPUT FORMAT I4P.
+INTEGER, PARAMETER :: DI2P  = 6    !< NUMBER OF DIGITS OF OUTPUT FORMAT I2P.
+INTEGER, PARAMETER :: DI1P  = 4    !< NUMBER OF DIGITS OF OUTPUT FORMAT I1P.
+INTEGER, PARAMETER :: DI_P  = DI4P !< NUMBER OF DIGITS OF OUTPUT FORMAT I_P.
+
+! LIST OF KINDS
+INTEGER,      PARAMETER :: CHARACTER_KINDS_LIST(1:3) = [ASCII, UCS4, CK]                        !< LIST OF CHARACTER KINDS.
+INTEGER,      PARAMETER :: REAL_KINDS_LIST(1:4)      = [R16P, R8P, R4P, R_P]                    !< LIST OF REAL KINDS.
+CHARACTER(*), PARAMETER :: REAL_FORMATS_LIST(1:4)    = [FR16P, FR8P, FR4P//' ', FR_P]           !< LIST OF REAL FORMATS.
+INTEGER,      PARAMETER :: INTEGER_KINDS_LIST(1:5)   = [I8P, I4P, I2P, I1P,I_P]                 !< LIST OF INTEGER KINDS.
+CHARACTER(*), PARAMETER :: INTEGER_FORMATS_LIST(1:5) = [FI8P, FI4P, FI2P//' ', FI1P//' ', FI_P] !< LIST OF INTEGER FORMATS.
+
+! MINIMUM AND MAXIMUM (REPRESENTABLE) VALUES
+REAL(R16P),   PARAMETER :: MINR16P = -HUGE(1._R16P) !< MINIMUM VALUE OF KIND=R16P REAL.
+REAL(R16P),   PARAMETER :: MAXR16P =  HUGE(1._R16P) !< MAXIMUM VALUE OF KIND=R16P REAL.
+REAL(R8P),    PARAMETER :: MINR8P  = -HUGE(1._R8P ) !< MINIMUM VALUE OF KIND=R8P REAL.
+REAL(R8P),    PARAMETER :: MAXR8P  =  HUGE(1._R8P ) !< MAXIMUM VALUE OF KIND=R8P REAL.
+REAL(R4P),    PARAMETER :: MINR4P  = -HUGE(1._R4P ) !< MINIMUM VALUE OF KIND=R4P REAL.
+REAL(R4P),    PARAMETER :: MAXR4P  =  HUGE(1._R4P ) !< MAXIMUM VALUE OF KIND=R4P REAL.
+REAL(R_P),    PARAMETER :: MINR_P  = -HUGE(1._R_P ) !< MINIMUM VALUE OF KIND=R_P REAL.
+REAL(R_P),    PARAMETER :: MAXR_P  =  HUGE(1._R_P ) !< MAXIMUM VALUE OF KIND=R_P REAL.
+INTEGER(I8P), PARAMETER :: MINI8P  = -HUGE(1_I8P)   !< MINIMUM VALUE OF KIND=I8P INTEGER.
+INTEGER(I4P), PARAMETER :: MINI4P  = -HUGE(1_I4P)   !< MINIMUM VALUE OF KIND=I4P INTEGER.
+INTEGER(I2P), PARAMETER :: MINI2P  = -HUGE(1_I2P)   !< MINIMUM VALUE OF KIND=I2P INTEGER.
+INTEGER(I1P), PARAMETER :: MINI1P  = -HUGE(1_I1P)   !< MINIMUM VALUE OF KIND=I1P INTEGER.
+INTEGER(I_P), PARAMETER :: MINI_P  = -HUGE(1_I_P)   !< MINIMUM VALUE OF KIND=I_P INTEGER.
+INTEGER(I8P), PARAMETER :: MAXI8P  =  HUGE(1_I8P)   !< MAXIMUM VALUE OF KIND=I8P INTEGER.
+INTEGER(I4P), PARAMETER :: MAXI4P  =  HUGE(1_I4P)   !< MAXIMUM VALUE OF KIND=I4P INTEGER.
+INTEGER(I2P), PARAMETER :: MAXI2P  =  HUGE(1_I2P)   !< MAXIMUM VALUE OF KIND=I2P INTEGER.
+INTEGER(I1P), PARAMETER :: MAXI1P  =  HUGE(1_I1P)   !< MAXIMUM VALUE OF KIND=I1P INTEGER.
+INTEGER(I_P), PARAMETER :: MAXI_P  =  HUGE(1_I_P)   !< MAXIMUM VALUE OF KIND=I_P INTEGER.
+
+! REAL SMALLEST (REPRESENTABLE) VALUES
+REAL(R16P), PARAMETER :: SMALLR16P = TINY(1._R16P) !< SMALLEST REPRESENTABLE VALUE OF KIND=R16P REAL.
+REAL(R8P),  PARAMETER :: SMALLR8P  = TINY(1._R8P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R8P REAL.
+REAL(R4P),  PARAMETER :: SMALLR4P  = TINY(1._R4P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R4P REAL.
+REAL(R_P),  PARAMETER :: SMALLR_P  = TINY(1._R_P ) !< SMALLEST REPRESENTABLE VALUE OF KIND=R_P REAL.
+
+! SMALLEST REAL REPRESENTABLE DIFFERENCE BY THE RUNNING CALCULATOR
+REAL(R16P), PARAMETER :: ZEROR16P = NEAREST(1._R16P, 1._R16P) - &
+                                    NEAREST(1._R16P,-1._R16P) !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R16P REAL.
+REAL(R8P),  PARAMETER :: ZEROR8P  = NEAREST(1._R8P, 1._R8P) - &
+                                    NEAREST(1._R8P,-1._R8P)   !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R8P REAL.
+REAL(R4P),  PARAMETER :: ZEROR4P  = NEAREST(1._R4P, 1._R4P) - &
+                                    NEAREST(1._R4P,-1._R4P)   !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R4P REAL.
+REAL(R_P),  PARAMETER :: ZEROR_P  = NEAREST(1._R_P, 1._R_P) - &
+                                    NEAREST(1._R_P,-1._R_P)   !< SMALLEST REPRESENTABLE DIFFERENCE OF KIND=R_P REAL.
+
+! BITS/BYTES MEMORY REQUIREMENTS (REAL VARIABLES MUST BE COMPUTED AT RUNTIME)
+INTEGER(I2P)            :: BIR16P                         !< NUMBER OF BITS OF KIND=R16P REAL.
+INTEGER(I1P)            :: BIR8P                          !< NUMBER OF BITS OF KIND=R8P REAL.
+INTEGER(I1P)            :: BIR4P                          !< NUMBER OF BITS OF KIND=R4P REAL.
+INTEGER(I1P)            :: BIR_P                          !< NUMBER OF BITS OF KIND=R_P REAL.
+INTEGER(I2P)            :: BYR16P                         !< NUMBER OF BYTES OF KIND=R16P REAL.
+INTEGER(I1P)            :: BYR8P                          !< NUMBER OF BYTES OF KIND=R8P REAL.
+INTEGER(I1P)            :: BYR4P                          !< NUMBER OF BYTES OF KIND=R4P REAL.
+INTEGER(I1P)            :: BYR_P                          !< NUMBER OF BYTES OF KIND=R_P REAL.
+INTEGER(I8P), PARAMETER :: BII8P = BIT_SIZE(MAXI8P)       !< NUMBER OF BITS OF KIND=I8P INTEGER.
+INTEGER(I4P), PARAMETER :: BII4P = BIT_SIZE(MAXI4P)       !< NUMBER OF BITS OF KIND=I4P INTEGER.
+INTEGER(I2P), PARAMETER :: BII2P = BIT_SIZE(MAXI2P)       !< NUMBER OF BITS OF KIND=I2P INTEGER.
+INTEGER(I1P), PARAMETER :: BII1P = BIT_SIZE(MAXI1P)       !< NUMBER OF BITS OF KIND=I1P INTEGER.
+INTEGER(I_P), PARAMETER :: BII_P = BIT_SIZE(MAXI_P)       !< NUMBER OF BITS OF KIND=I_P INTEGER.
+INTEGER(I8P), PARAMETER :: BYI8P = BIT_SIZE(MAXI8P)/8_I8P !< NUMBER OF BYTES OF KIND=I8P INTEGER.
+INTEGER(I4P), PARAMETER :: BYI4P = BIT_SIZE(MAXI4P)/8_I4P !< NUMBER OF BYTES OF KIND=I4P INTEGER.
+INTEGER(I2P), PARAMETER :: BYI2P = BIT_SIZE(MAXI2P)/8_I2P !< NUMBER OF BYTES OF KIND=I2P INTEGER.
+INTEGER(I1P), PARAMETER :: BYI1P = BIT_SIZE(MAXI1P)/8_I1P !< NUMBER OF BYTES OF KIND=I1P INTEGER.
+INTEGER(I_P), PARAMETER :: BYI_P = BIT_SIZE(MAXI_P)/8_I_P !< NUMBER OF BYTES OF KIND=I_P INTEGER.
+ENDMODULE PENF_GLOBAL_PARAMETERS_VARIABLES
+
+
+
+!< PENF BIT/BYTE SIZE FUNCTIONS.
+
+MODULE PENF_B_SIZE
+!< PENF BIT/BYTE SIZE FUNCTIONS.
+USE PENF_GLOBAL_PARAMETERS_VARIABLES
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+PUBLIC :: BIT_SIZE, BYTE_SIZE
+
+INTERFACE BIT_SIZE
+  !< OVERLOADING OF THE INTRINSIC *BIT_SIZE* FUNCTION FOR COMPUTING THE NUMBER OF BITS OF (ALSO) REAL AND CHARACTER VARIABLES.
+  MODULE PROCEDURE                &
+                   BIT_SIZE_R16P, &
+                   BIT_SIZE_R8P,  &
+                   BIT_SIZE_R4P,  &
+                   BIT_SIZE_CHR
+ENDINTERFACE
+
+INTERFACE BYTE_SIZE
+  !< COMPUTE THE NUMBER OF BYTES OF A VARIABLE.
+  MODULE PROCEDURE                 &
+                   BYTE_SIZE_I8P,  &
+                   BYTE_SIZE_I4P,  &
+                   BYTE_SIZE_I2P,  &
+                   BYTE_SIZE_I1P,  &
+                   BYTE_SIZE_R16P, &
+                   BYTE_SIZE_R8P,  &
+                   BYTE_SIZE_R4P,  &
+                   BYTE_SIZE_CHR
+ENDINTERFACE
+
+CONTAINS
+   ELEMENTAL FUNCTION BIT_SIZE_R16P(I) RESULT(BITS)
+   !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI2P, BIT_SIZE(1._R16P)
+   !<```
+   !=> 128 <<<
+   REAL(R16P), INTENT(IN) :: I       !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED.
+   INTEGER(I2P)           :: BITS    !< NUMBER OF BITS OF R.
+   INTEGER(I1P)           :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING.
+
+   BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I2P) * 8_I2P
+   ENDFUNCTION BIT_SIZE_R16P
+
+   ELEMENTAL FUNCTION BIT_SIZE_R8P(I) RESULT(BITS)
+   !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BIT_SIZE(1._R8P)
+   !<```
+   !=> 64 <<<
+   REAL(R8P), INTENT(IN) :: I       !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED.
+   INTEGER(I1P)          :: BITS    !< NUMBER OF BITS OF R.
+   INTEGER(I1P)          :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING.
+
+   BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I1P) * 8_I1P
+   ENDFUNCTION BIT_SIZE_R8P
+
+   ELEMENTAL FUNCTION BIT_SIZE_R4P(I) RESULT(BITS)
+   !< COMPUTE THE NUMBER OF BITS OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BIT_SIZE(1._R4P)
+   !<```
+   !=> 32 <<<
+   REAL(R4P), INTENT(IN) :: I       !< REAL VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED.
+   INTEGER(I1P)          :: BITS    !< NUMBER OF BITS OF R.
+   INTEGER(I1P)          :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING.
+
+   BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I1P) * 8_I1P
+   ENDFUNCTION BIT_SIZE_R4P
+
+   ELEMENTAL FUNCTION BIT_SIZE_CHR(I) RESULT(BITS)
+   !< COMPUTE THE NUMBER OF BITS OF A CHARACTER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, BIT_SIZE('AB')
+   !<```
+   !=> 16 <<<
+   CHARACTER(*), INTENT(IN) :: I       !< CHARACTER VARIABLE WHOSE NUMBER OF BITS MUST BE COMPUTED.
+   INTEGER(I4P)             :: BITS    !< NUMBER OF BITS OF C.
+   INTEGER(I1P)             :: MOLD(1) !< "MOLDING" DUMMY VARIABLE FOR BITS COUNTING.
+
+   BITS = SIZE(TRANSFER(I, MOLD), DIM=1, KIND=I4P) * 8_I4P
+   ENDFUNCTION BIT_SIZE_CHR
+
+   ELEMENTAL FUNCTION BYTE_SIZE_R16P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1._R16P)
+   !<```
+   !=> 16 <<<
+   REAL(R16P), INTENT(IN) :: I     !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)           :: BYTES !< NUMBER OF BYTES OF R.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_R16P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_R8P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1._R8P)
+   !<```
+   !=> 8 <<<
+   REAL(R8P), INTENT(IN) :: I     !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)          :: BYTES !< NUMBER OF BYTES OF R.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_R8P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_R4P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF A REAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1._R4P)
+   !<```
+   !=> 4 <<<
+   REAL(R4P), INTENT(IN) :: I     !< REAL VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)          :: BYTES !< NUMBER OF BYTES OF R.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_R4P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_CHR(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF A CHARACTER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE('AB')
+   !<```
+   !=> 2 <<<
+   CHARACTER(*), INTENT(IN) :: I     !< CHARACTER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I4P)             :: BYTES !< NUMBER OF BYTES OF C.
+
+   BYTES = BIT_SIZE(I) / 8_I4P
+   ENDFUNCTION BYTE_SIZE_CHR
+
+   ELEMENTAL FUNCTION BYTE_SIZE_I8P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1_I8P)
+   !<```
+   !=> 8 <<<
+   INTEGER(I8P), INTENT(IN) :: I     !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)             :: BYTES !< NUMBER OF BYTES OF I.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_I8P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_I4P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1_I4P)
+   !<```
+   !=> 4 <<<
+   INTEGER(I4P), INTENT(IN) :: I     !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)             :: BYTES !< NUMBER OF BYTES OF I.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_I4P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_I2P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1_I2P)
+   !<```
+   !=> 2 <<<
+   INTEGER(I2P), INTENT(IN) :: I     !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)             :: BYTES !< NUMBER OF BYTES OF I.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_I2P
+
+   ELEMENTAL FUNCTION BYTE_SIZE_I1P(I) RESULT(BYTES)
+   !< COMPUTE THE NUMBER OF BYTES OF AN INTEGER VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BYTE_SIZE(1_I1P)
+   !<```
+   !=> 1 <<<
+   INTEGER(I1P), INTENT(IN) :: I     !< INTEGER VARIABLE WHOSE NUMBER OF BYTES MUST BE COMPUTED.
+   INTEGER(I1P)             :: BYTES !< NUMBER OF BYTES OF I.
+
+   BYTES = BIT_SIZE(I) / 8_I1P
+   ENDFUNCTION BYTE_SIZE_I1P
+ENDMODULE PENF_B_SIZE
+
+
+!< PENF STRING-TO-NUMBER (AND VICEVERSA) FACILITY.
+
+MODULE PENF_STRINGIFY
+!< PENF STRING-TO-NUMBER (AND VICEVERSA) FACILITY.
+USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : STDERR=>ERROR_UNIT
+USE PENF_B_SIZE
+USE PENF_GLOBAL_PARAMETERS_VARIABLES
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+PUBLIC :: STR_ASCII, STR_UCS4
+PUBLIC :: STR, STRZ, CTON
+PUBLIC :: BSTR, BCTON
+
+INTERFACE STR_ASCII
+   !< CONVERT STRING OF ANY KIND TO ASCII STRING.
+   MODULE PROCEDURE STR_ASCII_DEFAULT
+#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT
+   MODULE PROCEDURE STR_ASCII_ASCII
+#endif
+#ifdef _UCS4_SUPPORTED
+   MODULE PROCEDURE STR_ASCII_UCS4
+#endif
+ENDINTERFACE
+
+INTERFACE STR_UCS4
+   !< CONVERT STRING OF ANY KIND TO UCS4 STRING.
+   MODULE PROCEDURE STR_UCS4_DEFAULT
+#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT
+   MODULE PROCEDURE STR_UCS4_ASCII
+#endif
+#ifdef _UCS4_SUPPORTED
+   MODULE PROCEDURE STR_UCS4_UCS4
+#endif
+ENDINTERFACE
+
+INTERFACE STR
+  !< CONVERT NUMBER (REAL AND INTEGER) TO STRING (NUMBER TO STRING TYPE CASTING).
+  MODULE PROCEDURE                       &
+                   STRF_R16P,STR_R16P,   &
+                   STRF_R8P ,STR_R8P,    &
+                   STRF_R4P ,STR_R4P,    &
+                   STRF_I8P ,STR_I8P,    &
+                   STRF_I4P ,STR_I4P,    &
+                   STRF_I2P ,STR_I2P,    &
+                   STRF_I1P ,STR_I1P,    &
+                             STR_BOL,    &
+                             STR_A_R16P, &
+                             STR_A_R8P,  &
+                             STR_A_R4P,  &
+                             STR_A_I8P,  &
+                             STR_A_I4P,  &
+                             STR_A_I2P,  &
+                             STR_A_I1P
+ENDINTERFACE
+
+INTERFACE STRZ
+  !< CONVERT INTEGER, TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS (INTEGER TO STRING TYPE CASTING WITH ZERO PADDING).
+  MODULE PROCEDURE STRZ_I8P, STRZ_I4P, STRZ_I2P, STRZ_I1P
+ENDINTERFACE
+
+INTERFACE CTON
+  !< CONVERT STRING TO NUMBER (REAL AND INTEGER, STRING TO NUMBER TYPE CASTING).
+  MODULE PROCEDURE            &
+                   CTOR_R16P, &
+                   CTOR_R8P,  &
+                   CTOR_R4P,  &
+                   CTOI_I8P,  &
+                   CTOI_I4P,  &
+                   CTOI_I2P,  &
+                   CTOI_I1P
+ENDINTERFACE
+
+INTERFACE BSTR
+  !< CONVERT NUMBER (REAL AND INTEGER) TO BIT-STRING (NUMBER TO BIT-STRING TYPE CASTING).
+  MODULE PROCEDURE            &
+                   BSTR_R16P, &
+                   BSTR_R8P,  &
+                   BSTR_R4P,  &
+                   BSTR_I8P,  &
+                   BSTR_I4P,  &
+                   BSTR_I2P,  &
+                   BSTR_I1P
+ENDINTERFACE
+
+INTERFACE BCTON
+  !< CONVERT BIT-STRING TO NUMBER (REAL AND INTEGER, BIT-STRING TO NUMBER TYPE CASTING).
+  MODULE PROCEDURE             &
+                   BCTOR_R16P, &
+                   BCTOR_R8P,  &
+                   BCTOR_R4P,  &
+                   BCTOI_I8P,  &
+                   BCTOI_I4P,  &
+                   BCTOI_I2P,  &
+                   BCTOI_I1P
+ENDINTERFACE
+
+CONTAINS
+   PURE FUNCTION STR_ASCII_DEFAULT(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF DEFAULT KIND TO ASCII STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM ASCII')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS DEFAULT KIND, BUT NOW I AM ASCII <<<
+   CHARACTER(LEN=*), INTENT(IN)              :: INPUT  !< INPUT STRING OF DEFAULT KIND.
+   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_ASCII_DEFAULT
+
+   PURE FUNCTION STR_ASCII_ASCII(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF ASCII KIND TO ASCII STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII('I WAS ASCII KIND AND I AM STILL ASCII')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS ASCII KIND AND I AM STILL ASCII <<<
+   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN)  :: INPUT  !< INPUT STRING OF ASCII KIND.
+   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_ASCII_ASCII
+
+   PURE FUNCTION STR_ASCII_UCS4(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF UCS4 KIND TO ASCII STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND, BUT NOW I AM ASCII')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS UCS4 KIND, BUT NOW I AM ASCII <<<
+   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)   :: INPUT  !< INPUT STRING OF UCS4 KIND.
+   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_ASCII_UCS4
+
+   PURE FUNCTION STR_UCS4_DEFAULT(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF DEFAULT KIND TO UCS4 STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM UCS4')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS DEFAULT KIND, BUT NOW I AM UCS4 <<<
+   CHARACTER(LEN=*), INTENT(IN)             :: INPUT  !< INPUT STRING OF DEFAULT KIND.
+   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_UCS4_DEFAULT
+
+   PURE FUNCTION STR_UCS4_ASCII(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF ASCII KIND TO UCS4 STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII(ASCII_'I WAS ASCII KIND, BUT NOW I AM UCS4')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS ASCII KIND, BUT NOW I AM UCS4 <<<
+   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT  !< INPUT STRING OF ASCII KIND.
+   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_UCS4_ASCII
+
+   PURE FUNCTION STR_UCS4_UCS4(INPUT) RESULT(OUTPUT)
+   !< CONVERT STRING OF UCS4 KIND TO UCS4 STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
+   !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND AND I AM STILL UCS4')
+   !< PRINT "(A)", STRING
+   !<```
+   !=> I WAS UCS4 KIND AND I AM STILL UCS4 <<<
+   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)  :: INPUT  !< INPUT STRING OF UCS4 KIND.
+   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
+
+   OUTPUT = INPUT
+   ENDFUNCTION STR_UCS4_UCS4
+
+   ELEMENTAL FUNCTION STRF_R16P(FM, N) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FR16P, N=1._R16P)
+   !<```
+   !=> 0.100000000000000000000000000000000E+0001 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   REAL(R16P),   INTENT(IN) :: N   !< REAL TO BE CONVERTED.
+   CHARACTER(DR16P)         :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_R16P
+
+   ELEMENTAL FUNCTION STRF_R8P(FM, N) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FR8P, N=1._R8P)
+   !<```
+   !=> 0.100000000000000E+001 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   REAL(R8P),    INTENT(IN) :: N   !< REAL TO BE CONVERTED.
+   CHARACTER(DR8P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_R8P
+
+   ELEMENTAL FUNCTION STRF_R4P(FM, N) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FR4P, N=1._R4P)
+   !<```
+   !=> 0.100000E+01 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   REAL(R4P),    INTENT(IN) :: N   !< REAL TO BE CONVERTED.
+   CHARACTER(DR4P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_R4P
+
+   ELEMENTAL FUNCTION STRF_I8P(FM, N) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FI8P, N=1_I8P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   INTEGER(I8P), INTENT(IN) :: N   !< INTEGER TO BE CONVERTED.
+   CHARACTER(DI8P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_I8P
+
+   ELEMENTAL FUNCTION STRF_I4P(FM, N) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FI4P, N=1_I4P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   INTEGER(I4P), INTENT(IN) :: N   !< INTEGER TO BE CONVERTED.
+   CHARACTER(DI4P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_I4P
+
+   ELEMENTAL FUNCTION STRF_I2P(FM, N) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FI2P, N=1_I2P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   INTEGER(I2P), INTENT(IN) :: N   !< INTEGER TO BE CONVERTED.
+   CHARACTER(DI2P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_I2P
+
+   ELEMENTAL FUNCTION STRF_I1P(FM, N) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(FM=FI1P, N=1_I1P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: FM  !< FORMAT DIFFERENT FROM THE STANDARD FOR THE KIND.
+   INTEGER(I1P), INTENT(IN) :: N   !< INTEGER TO BE CONVERTED.
+   CHARACTER(DI1P)          :: STR !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, TRIM(FM)) N
+   ENDFUNCTION STRF_I1P
+
+   ELEMENTAL FUNCTION STR_R16P(N, NO_SIGN, COMPACT) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R16P)
+   !<```
+   !=> -0.100000000000000000000000000000000E+0001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R16P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000000000000000000000000000000E+0001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R16P, COMPACT=.TRUE.)
+   !<```
+   !=> -0.1E+1 <<<
+   REAL(R16P), INTENT(IN)           :: N       !< REAL TO BE CONVERTED.
+   LOGICAL,    INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   LOGICAL,    INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(DR16P)                 :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, FR16P) N               ! CASTING OF N TO STRING.
+   IF (N>0._R16P) STR(1:1)='+'       ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   IF (PRESENT(COMPACT)) THEN
+     IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR)
+   ENDIF
+   ENDFUNCTION STR_R16P
+
+   ELEMENTAL FUNCTION STR_R8P(N, NO_SIGN, COMPACT) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R8P)
+   !<```
+   !=> -0.100000000000000E+001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R8P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000000000000E+001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R8P, COMPACT=.TRUE.)
+   !<```
+   !=> -0.1E+1 <<<
+   REAL(R8P), INTENT(IN)           :: N       !< REAL TO BE CONVERTED.
+   LOGICAL,   INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   LOGICAL,   INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(DR8P)                 :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, FR8P) N                ! CASTING OF N TO STRING.
+   IF (N>0._R8P) STR(1:1)='+'        ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   IF (PRESENT(COMPACT)) THEN
+     IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR)
+   ENDIF
+   ENDFUNCTION STR_R8P
+
+   ELEMENTAL FUNCTION STR_R4P(N, NO_SIGN, COMPACT) RESULT(STR)
+   !< CONVERT REAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R4P)
+   !<```
+   !=> -0.100000E+01 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R4P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000E+01 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1._R4P, COMPACT=.TRUE.)
+   !<```
+   !=> -0.1E+1 <<<
+   REAL(R4P), INTENT(IN)           :: N       !< REAL TO BE CONVERTED.
+   LOGICAL,   INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   LOGICAL,   INTENT(IN), OPTIONAL :: COMPACT !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(DR4P)                 :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER.
+
+   WRITE(STR, FR4P) N                ! CASTING OF N TO STRING.
+   IF (N>0._R4P) STR(1:1)='+'        ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   IF (PRESENT(COMPACT)) THEN
+     IF (COMPACT) CALL COMPACT_REAL_STRING(STRING=STR)
+   ENDIF
+   ENDFUNCTION STR_R4P
+
+   ELEMENTAL FUNCTION STR_I8P(N, NO_SIGN) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I8P)
+   !<```
+   !=> -1 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I8P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 1 <<<
+   INTEGER(I8P), INTENT(IN)           :: N       !< INTEGER TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(DI8P)                    :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR, FI8P) N                ! CASTING OF N TO STRING.
+   STR = ADJUSTL(TRIM(STR))          ! REMOVING WHITE SPACES.
+   IF (N>=0_I8P) STR='+'//TRIM(STR)  ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   ENDFUNCTION STR_I8P
+
+   ELEMENTAL FUNCTION STR_I4P(N, NO_SIGN) RESULT(STR)
+   !< CONVERTING INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I4P)
+   !<```
+   !=> -1 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I4P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 1 <<<
+   INTEGER(I4P), INTENT(IN)           :: N       !< INTEGER TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(DI4P)                    :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR, FI4P) N                ! CASTING OF N TO STRING.
+   STR = ADJUSTL(TRIM(STR))          ! REMOVING WHITE SPACES.
+   IF (N>=0_I4P) STR='+'//TRIM(STR)  ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   ENDFUNCTION STR_I4P
+
+   ELEMENTAL FUNCTION STR_I2P(N, NO_SIGN) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I2P)
+   !<```
+   !=> -1 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I2P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 1 <<<
+   INTEGER(I2P), INTENT(IN)           :: N       !< INTEGER TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(DI2P)                    :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR, FI2P) N                ! CASTING OF N TO STRING.
+   STR = ADJUSTL(TRIM(STR))          ! REMOVING WHITE SPACES.
+   IF (N>=0_I2P) STR='+'//TRIM(STR)  ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   ENDFUNCTION STR_I2P
+
+   ELEMENTAL FUNCTION STR_I1P(N, NO_SIGN) RESULT(STR)
+   !< CONVERT INTEGER TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I1P)
+   !<```
+   !=> -1 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=-1_I1P, NO_SIGN=.TRUE.)
+   !<```
+   !=> 1 <<<
+   INTEGER(I1P), INTENT(IN)           :: N       !< INTEGER TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(DI1P)                    :: STR     !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR, FI1P) N                ! CASTING OF N TO STRING.
+   STR = ADJUSTL(TRIM(STR))          ! REMOVING WHITE SPACES.
+   IF (N>=0_I1P) STR='+'//TRIM(STR)  ! PREFIXING PLUS IF N>0.
+   IF (PRESENT(NO_SIGN)) STR=STR(2:) ! LEAVING OUT THE SIGN.
+   ENDFUNCTION STR_I1P
+
+   ELEMENTAL FUNCTION STR_BOL(N) RESULT(STR)
+   !< CONVERT LOGICAL TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=.TRUE.)
+   !<```
+   !=> T <<<
+   LOGICAL, INTENT(IN):: N   !< LOGICAL TO BE CONVERTED.
+   CHARACTER(1)::        STR !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR, '(L1)') N
+   ENDFUNCTION STR_BOL
+
+   PURE FUNCTION STR_A_R16P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR)
+   !< CONVERTING REAL ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R16P, -2._R16P])
+   !<```
+   !=> +0.100000000000000000000000000000000E+0001,-0.200000000000000000000000000000000E+0001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R16P, 2._R16P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000000000000000000000000000000E+0001,0.200000000000000000000000000000000E+0001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], SEPARATOR='|')
+   !<```
+   !=> +0.100000000000000000000000000000000E+0001|-0.200000000000000000000000000000000E+0001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+0.100000000000000000000000000000000E+0001,-0.200000000000000000000000000000000E+0001) <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R16P, -2._R16P], COMPACT=.TRUE.)
+   !<```
+   !=> +0.1E+1,-0.2E+1 <<<
+   REAL(R16P),   INTENT(IN)           :: N(:)            !< REAL ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   LOGICAL,      INTENT(IN), OPTIONAL :: COMPACT         !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DR16P)                   :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   DO I=1,SIZE(N)
+     STRN = STR_R16P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I))
+     STR = STR//SEP//TRIM(STRN)
+   ENDDO
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_R16P
+
+   PURE FUNCTION STR_A_R8P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR)
+   !< CONVERT REAL ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R8P, -2._R8P])
+   !<```
+   !=> +0.100000000000000E+001,-0.200000000000000E+001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R8P, 2._R8P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000000000000E+001,0.200000000000000E+001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], SEPARATOR='|')
+   !<```
+   !=> +0.100000000000000E+001|-0.200000000000000E+001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+0.100000000000000E+001,-0.200000000000000E+001) <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R8P, -2._R8P], COMPACT=.TRUE.)
+   !<```
+   !=> +0.1E+1,-0.2E+1 <<<
+   REAL(R8P),    INTENT(IN)           :: N(:)            !< REAL ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   LOGICAL,      INTENT(IN), OPTIONAL :: COMPACT         !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DR8P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   DO I=1,SIZE(N)
+     STRN = STR_R8P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I))
+     STR = STR//SEP//TRIM(STRN)
+   ENDDO
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_R8P
+
+   PURE FUNCTION STR_A_R4P(N, NO_SIGN, SEPARATOR, DELIMITERS, COMPACT) RESULT(STR)
+   !< CONVERT REAL ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R4P, -2._R4P])
+   !<```
+   !=> +0.100000E+01,-0.200000E+01 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R4P, 2._R4P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 0.100000E+01,0.200000E+01 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], SEPARATOR='|')
+   !<```
+   !=> +0.100000E+01|-0.200000E+01 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+0.100000E+01,-0.200000E+01) <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1._R4P, -2._R4P], COMPACT=.TRUE.)
+   !<```
+   !=> +0.1E+1,-0.2E+1 <<<
+   REAL(R4P),    INTENT(IN)           :: N(:)            !< REAL ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   LOGICAL,      INTENT(IN), OPTIONAL :: COMPACT         !< FLAG FOR *COMPACTING* STRING ENCODING.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DR4P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   DO I=1,SIZE(N)
+     STRN = STR_R4P(NO_SIGN=NO_SIGN, COMPACT=COMPACT, N=N(I))
+     STR = STR//SEP//TRIM(STRN)
+   ENDDO
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_R4P
+
+   PURE FUNCTION STR_A_I8P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR)
+   !< CONVERT INTEGER ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I8P, -2_I8P])
+   !<```
+   !=> +1,-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I8P, 2_I8P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 1,2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I8P, -2_I8P], SEPARATOR='|')
+   !<```
+   !=> +1|-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I8P, -2_I8P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+1,-2) <<<
+   INTEGER(I8P), INTENT(IN)           :: N(:)            !< INTEGER ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DI8P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   IF (PRESENT(NO_SIGN)) THEN
+     DO I=1,SIZE(N)
+       STRN = STR_I8P(NO_SIGN=NO_SIGN, N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ELSE
+     DO I=1,SIZE(N)
+       STRN = STR_I8P(N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ENDIF
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_I8P
+
+   PURE FUNCTION STR_A_I4P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR)
+   !< CONVERT INTEGER ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I4P, -2_I4P])
+   !<```
+   !=> +1,-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I4P, 2_I4P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 1,2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I4P, -2_I4P], SEPARATOR='|')
+   !<```
+   !=> +1|-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I4P, -2_I4P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+1,-2) <<<
+   INTEGER(I4P), INTENT(IN)           :: N(:)            !< INTEGER ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DI4P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   IF (PRESENT(NO_SIGN)) THEN
+     DO I=1,SIZE(N)
+       STRN = STR_I4P(NO_SIGN=NO_SIGN, N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ELSE
+     DO I=1,SIZE(N)
+       STRN = STR_I4P(N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ENDIF
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_I4P
+
+   PURE FUNCTION STR_A_I2P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR)
+   !< CONVERT INTEGER ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I2P, -2_I2P])
+   !<```
+   !=> +1,-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I2P, 2_I2P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 1,2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I2P, -2_I2P], SEPARATOR='|')
+   !<```
+   !=> +1|-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I2P, -2_I2P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+1,-2) <<<
+   INTEGER(I2P), INTENT(IN)           :: N(:)            !< INTEGER ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DI2P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   IF (PRESENT(NO_SIGN)) THEN
+     DO I=1,SIZE(N)
+       STRN = STR_I2P(NO_SIGN=NO_SIGN, N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ELSE
+     DO I=1,SIZE(N)
+       STRN = STR_I2P(N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ENDIF
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_I2P
+
+   PURE FUNCTION STR_A_I1P(N, NO_SIGN, SEPARATOR, DELIMITERS) RESULT(STR)
+   !< CONVERT INTEGER ARRAY TO STRING.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I1P, -2_I1P])
+   !<```
+   !=> +1,-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I1P, 2_I1P], NO_SIGN=.TRUE.)
+   !<```
+   !=> 1,2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I1P, -2_I1P], SEPARATOR='|')
+   !<```
+   !=> +1|-2 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STR(N=[1_I1P, -2_I1P], DELIMITERS=['(', ')'])
+   !<```
+   !=> (+1,-2) <<<
+   INTEGER(I1P), INTENT(IN)           :: N(:)            !< INTEGER ARRAY TO BE CONVERTED.
+   LOGICAL,      INTENT(IN), OPTIONAL :: NO_SIGN         !< FLAG FOR LEAVING OUT THE SIGN.
+   CHARACTER(1), INTENT(IN), OPTIONAL :: SEPARATOR       !< EVENTUAL SEPARATOR OF ARRAY VALUES.
+   CHARACTER(*), INTENT(IN), OPTIONAL :: DELIMITERS(1:2) !< EVENTUAL DELIMITERS OF ARRAY VALUES.
+   CHARACTER(LEN=:), ALLOCATABLE      :: STR             !< RETURNED STRING CONTAINING INPUT NUMBER.
+   CHARACTER(DI1P)                    :: STRN            !< STRING CONTAINING OF ELEMENT OF INPUT ARRAY NUMBER.
+   CHARACTER(LEN=1)                   :: SEP             !< ARRAY VALUES SEPARATOR
+   INTEGER                            :: I               !< COUNTER.
+
+   STR = ''
+   SEP = ','
+   IF(PRESENT(SEPARATOR)) SEP = SEPARATOR
+   IF (PRESENT(NO_SIGN)) THEN
+     DO I=1,SIZE(N)
+       STRN = STR_I1P(NO_SIGN=NO_SIGN, N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ELSE
+     DO I=1,SIZE(N)
+       STRN = STR_I1P(N=N(I))
+       STR = STR//SEP//TRIM(STRN)
+     ENDDO
+   ENDIF
+   STR = TRIM(STR(2:))
+   IF (PRESENT(DELIMITERS)) STR = DELIMITERS(1)//STR//DELIMITERS(2)
+   ENDFUNCTION STR_A_I1P
+
+   PURE SUBROUTINE COMPACT_REAL_STRING(STRING)
+   !< AUTHOR: IZAAK BEEKMAN
+   !< DATE: 02/24/2015
+   !<
+   !< COMPACT A STRING REPRESENTING A REAL NUMBER, SO THAT THE SAME VALUE IS DISPLAYED WITH FEWER CHARACTERS.
+   !<
+   !< @NOTE NO NEED TO ADD DOCTEST: THIS IS TESTED BY A LOT OF DOCTESTS OF OTHER TBPS.
+   CHARACTER(LEN=*),INTENT(INOUT) :: STRING      !< STRING REPRESENTATION OF A REAL NUMBER.
+   CHARACTER(LEN=LEN(STRING))     :: SIGNIFICAND !< SIGNIFICAND CHARACTERS.
+   CHARACTER(LEN=LEN(STRING))     :: EXPNT       !< EXPONENT CHARACTERS.
+   CHARACTER(LEN=2)               :: SEPARATOR   !< SEPARATOR CHARACTERS.
+   INTEGER(I4P)                   :: EXP_START   !< START POSITION OF EXPONENT.
+   INTEGER(I4P)                   :: DECIMAL_POS !< DECIMAL POSITIONS.
+   INTEGER(I4P)                   :: SIG_TRIM    !< SIGNATURE TRIM.
+   INTEGER(I4P)                   :: EXP_TRIM    !< EXPONENT TRIM.
+   INTEGER(I4P)                   :: I           !< COUNTER
+
+   STRING = ADJUSTL(STRING)
+   EXP_START = SCAN(STRING, 'EEDD')
+   IF (EXP_START == 0) EXP_START = SCAN(STRING, '-+', BACK=.TRUE.)
+   DECIMAL_POS = SCAN(STRING, '.')
+   IF (EXP_START /= 0) SEPARATOR = STRING(EXP_START:EXP_START)
+   IF ( EXP_START < DECIMAL_POS ) THEN ! POSSIBLY SIGNED, EXPONENT-LESS FLOAT
+     SIGNIFICAND = STRING
+     SIG_TRIM = LEN(TRIM(SIGNIFICAND))
+     DO I = LEN(TRIM(SIGNIFICAND)), DECIMAL_POS+2, -1 ! LOOK FROM RIGHT TO LEFT AT 0S, BUT SAVE ONE AFTER THE DECIMAL PLACE
+       IF (SIGNIFICAND(I:I) == '0') THEN
+         SIG_TRIM = I-1
+       ELSE
+         EXIT
+       ENDIF
+     ENDDO
+     STRING = TRIM(SIGNIFICAND(1:SIG_TRIM))
+   ELSEIF (EXP_START > DECIMAL_POS) THEN ! FLOAT HAS EXPONENT
+     SIGNIFICAND = STRING(1:EXP_START-1)
+     SIG_TRIM = LEN(TRIM(SIGNIFICAND))
+     DO I = LEN(TRIM(SIGNIFICAND)),DECIMAL_POS+2,-1 ! LOOK FROM RIGHT TO LEFT AT 0S
+       IF (SIGNIFICAND(I:I) == '0') THEN
+         SIG_TRIM = I-1
+       ELSE
+         EXIT
+       ENDIF
+     ENDDO
+     EXPNT = ADJUSTL(STRING(EXP_START+1:))
+     IF (EXPNT(1:1) == '+' .OR. EXPNT(1:1) == '-') THEN
+       SEPARATOR = TRIM(ADJUSTL(SEPARATOR))//EXPNT(1:1)
+       EXP_START = EXP_START + 1
+       EXPNT     = ADJUSTL(STRING(EXP_START+1:))
+     ENDIF
+     EXP_TRIM = 1
+     DO I = 1,(LEN(TRIM(EXPNT))-1) ! LOOK AT EXPONENT LEADING ZEROS SAVING LAST
+       IF (EXPNT(I:I) == '0') THEN
+         EXP_TRIM = I+1
+       ELSE
+         EXIT
+       ENDIF
+     ENDDO
+     STRING = TRIM(ADJUSTL(SIGNIFICAND(1:SIG_TRIM)))// &
+              TRIM(ADJUSTL(SEPARATOR))// &
+              TRIM(ADJUSTL(EXPNT(EXP_TRIM:)))
+   !ELSE ! MAL-FORMED REAL, BUT THIS CODE SHOULD BE UNREACHABLE
+   ENDIF
+   ENDSUBROUTINE COMPACT_REAL_STRING
+
+   ELEMENTAL FUNCTION STRZ_I8P(N, NZ_PAD) RESULT(STR)
+   !< CONVERTING INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I8P)
+   !<```
+   !=> 0000000000000000001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I8P, NZ_PAD=5)
+   !<```
+   !=> 00001 <<<
+   INTEGER(I8P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
+   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
+   CHARACTER(DI8P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR,FI8PZP) N                              ! CASTING OF N TO STRING.
+   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
+   IF (PRESENT(NZ_PAD)) STR=STR(DI8P-NZ_PAD:DI8P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
+   ENDFUNCTION STRZ_I8P
+
+   ELEMENTAL FUNCTION STRZ_I4P(N, NZ_PAD) RESULT(STR)
+   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I4P)
+   !<```
+   !=> 0000000001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I4P, NZ_PAD=5)
+   !<```
+   !=> 00001 <<<
+   INTEGER(I4P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
+   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
+   CHARACTER(DI4P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR,FI4PZP) N                              ! CASTING OF N TO STRING.
+   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
+   IF (PRESENT(NZ_PAD)) STR=STR(DI4P-NZ_PAD:DI4P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
+   ENDFUNCTION STRZ_I4P
+
+   ELEMENTAL FUNCTION STRZ_I2P(N, NZ_PAD) RESULT(STR)
+   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I2P)
+   !<```
+   !=> 00001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I2P, NZ_PAD=3)
+   !<```
+   !=> 001 <<<
+   INTEGER(I2P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
+   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
+   CHARACTER(DI2P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR,FI2PZP) N                              ! CASTING OF N TO STRING.
+   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
+   IF (PRESENT(NZ_PAD)) STR=STR(DI2P-NZ_PAD:DI2P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
+   ENDFUNCTION STRZ_I2P
+
+   ELEMENTAL FUNCTION STRZ_I1P(N, NZ_PAD) RESULT(STR)
+   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I1P)
+   !<```
+   !=> 001 <<<
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", STRZ(N=1_I1P, NZ_PAD=3)
+   !<```
+   !=> 001 <<<
+   INTEGER(I1P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
+   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
+   CHARACTER(DI1P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+
+   WRITE(STR,FI1PZP) N                              ! CASTING OF N TO STRING.
+   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
+   IF (PRESENT(NZ_PAD)) STR=STR(DI1P-NZ_PAD:DI1P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
+   ENDFUNCTION STRZ_I1P
+
+   FUNCTION CTOR_R16P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR16P, CTON(STR='-1.0', KND=1._R16P)
+   !<```
+   !=> -0.100000000000000000000000000000000E+0001 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   REAL(R16P),             INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   REAL(R16P)                          :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOR_R16P
+
+   FUNCTION CTOR_R8P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR8P, CTON(STR='-1.0', KND=1._R8P)
+   !<```
+   !=> -0.100000000000000E+001 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   REAL(R8P),              INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   REAL(R8P)                           :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOR_R8P
+
+   FUNCTION CTOR_R4P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR4P, CTON(STR='-1.0', KND=1._R4P)
+   !<```
+   !=> -0.100000E+01 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   REAL(R4P),              INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   REAL(R4P)                           :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOR_R4P
+
+   FUNCTION CTOI_I8P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI8P, CTON(STR='-1', KND=1_I8P)
+   !<```
+   !=> -1 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I8P),           INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   INTEGER(I8P)                        :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOI_I8P
+
+   FUNCTION CTOI_I4P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, CTON(STR='-1', KND=1_I4P)
+   !<```
+   !=> -1 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I4P),           INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   INTEGER(I4P)                        :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOI_I4P
+
+   FUNCTION CTOI_I2P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI2P, CTON(STR='-1', KND=1_I2P)
+   !<```
+   !=> -1 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I2P),           INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   INTEGER(I2P)                        :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOI_I2P
+
+   FUNCTION CTOI_I1P(STR, KND, PREF, ERROR) RESULT(N)
+   !< CONVERT STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, CTON(STR='-1', KND=1_I1P)
+   !<```
+   !=> -1 <<<
+   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I1P),           INTENT(IN)  :: KND   !< NUMBER KIND.
+   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
+   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   INTEGER(I1P)                        :: N     !< NUMBER RETURNED.
+   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
+
+   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
+   IF (ERR/=0) THEN
+     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
+   ENDIF
+   IF (PRESENT(ERROR)) ERROR = ERR
+   ENDFUNCTION CTOI_I1P
+
+   ELEMENTAL FUNCTION BSTR_R16P(N) RESULT(BSTR)
+   !< CONVERT REAL TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT R16P IS REPRESENTED BY MEANS OF 128 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CHARACTER(128) :: B
+   !< B = BSTR(N=1._R16P)
+   !< PRINT "(A)", B(17:)
+   !<```
+   !=> 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111100111111 <<<
+   REAL(R16P), INTENT(IN) :: N          !< REAL TO BE CONVERTED.
+   CHARACTER(128)         :: BSTR       !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+   INTEGER(I1P)           :: BUFFER(16) !< TRANSFER BUFFER.
+
+   BUFFER = TRANSFER(N, BUFFER)
+   WRITE(BSTR, '(16B8.8)') BUFFER
+   ENDFUNCTION BSTR_R16P
+
+   ELEMENTAL FUNCTION BSTR_R8P(N) RESULT(BSTR)
+   !< CONVERT REAL TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT R8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1._R8P)
+   !<```
+   !=> 0000000000000000000000000000000000000000000000001111000000111111 <<<
+   REAL(R8P), INTENT(IN) :: N         !< REAL TO BE CONVERTED.
+   CHARACTER(64)         :: BSTR      !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+   INTEGER(I1P)          :: BUFFER(8) !< TRANSFER BUFFER.
+
+   BUFFER = TRANSFER(N, BUFFER)
+   WRITE(BSTR, '(8B8.8)') BUFFER
+   ENDFUNCTION BSTR_R8P
+
+   ELEMENTAL FUNCTION BSTR_R4P(N) RESULT(BSTR)
+   !< CONVERT REAL TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT R4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1._R4P)
+   !<```
+   !=> 00000000000000001000000000111111 <<<
+   REAL(R4P), INTENT(IN) :: N         !< REAL TO BE CONVERTED.
+   CHARACTER(32)         :: BSTR      !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+   INTEGER(I1P)          :: BUFFER(4) !< TRANSFER BUFFER.
+
+   BUFFER = TRANSFER(N, BUFFER)
+   WRITE(BSTR, '(4B8.8)') BUFFER
+   ENDFUNCTION BSTR_R4P
+
+   ELEMENTAL FUNCTION BSTR_I8P(N) RESULT(BSTR)
+   !< CONVERT INTEGER TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT I8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1_I8P)
+   !<```
+   !=> 0000000000000000000000000000000000000000000000000000000000000001 <<<
+   INTEGER(I8P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
+   CHARACTER(64)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+
+   WRITE(BSTR, '(B64.64)') N
+   ENDFUNCTION BSTR_I8P
+
+   ELEMENTAL FUNCTION BSTR_I4P(N) RESULT(BSTR)
+   !< CONVERT INTEGER TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT I4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1_I4P)
+   !<```
+   !=> 00000000000000000000000000000001 <<<
+   INTEGER(I4P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
+   CHARACTER(32)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+
+   WRITE(BSTR, '(B32.32)') N
+   ENDFUNCTION BSTR_I4P
+
+   ELEMENTAL FUNCTION BSTR_I2P(N) RESULT(BSTR)
+   !< CONVERT INTEGER TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT I2P IS REPRESENTED BY MEANS OF 16 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1_I2P)
+   !<```
+   !=> 0000000000000001 <<<
+   INTEGER(I2P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
+   CHARACTER(16)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+
+   WRITE(BSTR, '(B16.16)') N
+   ENDFUNCTION BSTR_I2P
+
+   ELEMENTAL FUNCTION BSTR_I1P(N) RESULT(BSTR)
+   !< CONVERT INTEGER TO STRING OF BITS.
+   !<
+   !< @NOTE IT IS ASSUMED THAT I1P IS REPRESENTED BY MEANS OF 8 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT "(A)", BSTR(N=1_I1P)
+   !<```
+   !=> 00000001 <<<
+   INTEGER(I1P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
+   CHARACTER(8)             :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
+
+   WRITE(BSTR, '(B8.8)') N
+   ENDFUNCTION BSTR_I1P
+
+   ELEMENTAL FUNCTION BCTOR_R16P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR16P, BCTON('00000000000000000000000000000000000000000000000000000000000000000000000000000'//&
+   !<                    '000000000000000000000000000000000001111111100111111', KND=1._R16P)
+   !<```
+   !=> 0.100000000000000000000000000000000E+0001 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR       !< STRING CONTAINING INPUT NUMBER.
+   REAL(R16P),   INTENT(IN) :: KND        !< NUMBER KIND.
+   REAL(R16P)               :: N          !< NUMBER RETURNED.
+   INTEGER(I1P)             :: BUFFER(16) !< TRANSFER BUFFER.
+
+   READ(BSTR, '(16B8.8)') BUFFER
+   N = TRANSFER(BUFFER, N)
+   ENDFUNCTION BCTOR_R16P
+
+   ELEMENTAL FUNCTION BCTOR_R8P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR8P, BCTON('0000000000000000000000000000000000000000000000001111000000111111', KND=1._R8P)
+   !<```
+   !=> 0.100000000000000E+001 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR      !< STRING CONTAINING INPUT NUMBER.
+   REAL(R8P),    INTENT(IN) :: KND       !< NUMBER KIND.
+   REAL(R8P)                :: N         !< NUMBER RETURNED.
+   INTEGER(I1P)             :: BUFFER(8) !< TRANSFER BUFFER.
+
+   READ(BSTR, '(8B8.8)') BUFFER
+   N = TRANSFER(BUFFER, N)
+   ENDFUNCTION BCTOR_R8P
+
+   ELEMENTAL FUNCTION BCTOR_R4P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO REAL.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FR4P, BCTON('00000000000000001000000000111111', KND=1._R4P)
+   !<```
+   !=> 0.100000E+01 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR      !< STRING CONTAINING INPUT NUMBER.
+   REAL(R4P),    INTENT(IN) :: KND       !< NUMBER KIND.
+   REAL(R4P)                :: N         !< NUMBER RETURNED.
+   INTEGER(I1P)             :: BUFFER(4) !< TRANSFER BUFFER.
+
+   READ(BSTR, '(4B8.8)') BUFFER
+   N = TRANSFER(BUFFER, N)
+   ENDFUNCTION BCTOR_R4P
+
+   ELEMENTAL FUNCTION BCTOI_I8P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI8P, BCTON('0000000000000000000000000000000000000000000000000000000000000001', KND=1_I8P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I8P), INTENT(IN) :: KND  !< NUMBER KIND.
+   INTEGER(I8P)             :: N    !< NUMBER RETURNED.
+
+   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
+   ENDFUNCTION BCTOI_I8P
+
+   ELEMENTAL FUNCTION BCTOI_I4P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, BCTON('00000000000000000000000000000001', KND=1_I4P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I4P), INTENT(IN) :: KND  !< NUMBER KIND.
+   INTEGER(I4P)             :: N    !< NUMBER RETURNED.
+
+   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
+   ENDFUNCTION BCTOI_I4P
+
+   ELEMENTAL FUNCTION BCTOI_I2P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI2P, BCTON('0000000000000001', KND=1_I2P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I2P), INTENT(IN) :: KND  !< NUMBER KIND.
+   INTEGER(I2P)             :: N    !< NUMBER RETURNED.
+
+   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
+   ENDFUNCTION BCTOI_I2P
+
+   ELEMENTAL FUNCTION BCTOI_I1P(BSTR, KND) RESULT(N)
+   !< CONVERT BIT-STRING TO INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI1P, BCTON('00000001', KND=1_I1P)
+   !<```
+   !=> 1 <<<
+   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
+   INTEGER(I1P), INTENT(IN) :: KND  !< NUMBER KIND.
+   INTEGER(I1P)             :: N    !< NUMBER RETURNED.
+
+   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
+   ENDFUNCTION BCTOI_I1P
+ENDMODULE PENF_STRINGIFY
+
+
+!< PORTABILITY ENVIRONMENT FOR FORTRAN POOR PEOPLE.
+
+MODULE PENF
+!< PORTABILITY ENVIRONMENT FOR FORTRAN POOR PEOPLE.
+USE PENF_GLOBAL_PARAMETERS_VARIABLES
+#ifdef __INTEL_COMPILER
+USE PENF_B_SIZE
+#else
+USE PENF_B_SIZE, ONLY : BIT_SIZE, BYTE_SIZE
+#endif
+USE PENF_STRINGIFY, ONLY : STR_ASCII, STR_UCS4, STR, STRZ, CTON, BSTR, BCTON
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+! GLOBAL PARAMETERS AND VARIABLES
+PUBLIC :: ENDIANL, ENDIANB, ENDIAN, IS_INITIALIZED
+PUBLIC :: ASCII, UCS4, CK
+PUBLIC :: R16P, FR16P, DR16P, MINR16P, MAXR16P, BIR16P, BYR16P, SMALLR16P, ZEROR16P
+PUBLIC :: R8P,  FR8P,  DR8P,  MINR8P,  MAXR8P,  BIR8P,  BYR8P,  SMALLR8P,  ZEROR8P
+PUBLIC :: R4P,  FR4P,  DR4P,  MINR4P,  MAXR4P,  BIR4P,  BYR4P,  SMALLR4P,  ZEROR4P
+PUBLIC :: R_P,  FR_P,  DR_P,  MINR_P,  MAXR_P,  BIR_P,  BYR_P,  SMALLR_P,  ZEROR_P
+PUBLIC :: I8P,  FI8P,  DI8P,  MINI8P,  MAXI8P,  BII8P,  BYI8P
+PUBLIC :: I4P,  FI4P,  DI4P,  MINI4P,  MAXI4P,  BII4P,  BYI4P
+PUBLIC :: I2P,  FI2P,  DI2P,  MINI2P,  MAXI2P,  BII2P,  BYI2P
+PUBLIC :: I1P,  FI1P,  DI1P,  MINI1P,  MAXI1P,  BII1P,  BYI1P
+PUBLIC :: I_P,  FI_P,  DI_P,  MINI_P,  MAXI_P,  BII_P,  BYI_P
+PUBLIC :: CHARACTER_KINDS_LIST, REAL_KINDS_LIST, REAL_FORMATS_LIST
+PUBLIC :: INTEGER_KINDS_LIST, INTEGER_FORMATS_LIST
+! BIT/BYTE SIZE FUNCTIONS
+PUBLIC :: BIT_SIZE, BYTE_SIZE
+! STRINGIFY FACILITY
+PUBLIC :: STR_ASCII, STR_UCS4
+PUBLIC :: STR, STRZ, CTON
+PUBLIC :: BSTR, BCTON
+! MISCELLANEA FACILITY
+PUBLIC :: CHECK_ENDIAN
+PUBLIC :: DIGIT
+PUBLIC :: PENF_INIT
+PUBLIC :: PENF_PRINT
+
+INTEGER, PROTECTED :: ENDIAN         = ENDIANL !< BIT ORDERING: LITTLE ENDIAN (ENDIANL), OR BIG ENDIAN (ENDIANB).
+LOGICAL, PROTECTED :: IS_INITIALIZED = .FALSE. !< CHECK THE INITIALIZATION OF SOME VARIABLES THAT MUST BE INITIALIZED.
+
+#ifdef __GFORTRAN__
+! WORK-AROUND FOR STRANGE GFORTRAN BUG...
+INTERFACE BIT_SIZE
+  !< OVERLOADING OF THE INTRINSIC *BIT_SIZE* FUNCTION FOR COMPUTING THE NUMBER OF BITS OF (ALSO) REAL AND CHARACTER VARIABLES.
+ENDINTERFACE
+#endif
+
+INTERFACE DIGIT
+  !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER.
+  MODULE PROCEDURE DIGIT_I8, DIGIT_I4, DIGIT_I2, DIGIT_I1
+ENDINTERFACE
+
+CONTAINS
+   ! PUBLIC PROCEDURES
+   SUBROUTINE CHECK_ENDIAN()
+   !< CHECK THE TYPE OF BIT ORDERING (BIG OR LITTLE ENDIAN) OF THE RUNNING ARCHITECTURE.
+   !<
+   !> @NOTE THE RESULT IS STORED INTO THE *ENDIAN* GLOBAL VARIABLE.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CALL CHECK_ENDIAN
+   !< PRINT *, ENDIAN
+   !<```
+   !=> 1 <<<
+   IF (IS_LITTLE_ENDIAN()) THEN
+      ENDIAN = ENDIANL
+   ELSE
+      ENDIAN = ENDIANB
+   ENDIF
+   CONTAINS
+      PURE FUNCTION IS_LITTLE_ENDIAN() RESULT(IS_LITTLE)
+      !< CHECK IF THE TYPE OF THE BIT ORDERING OF THE RUNNING ARCHITECTURE IS LITTLE ENDIAN.
+      LOGICAL      :: IS_LITTLE !< LOGICAL OUTPUT: TRUE IS THE RUNNING ARCHITECTURE USES LITTLE ENDIAN ORDERING, FALSE OTHERWISE.
+      INTEGER(I1P) :: INT1(1:4) !< ONE BYTE INTEGER ARRAY FOR CASTING 4 BYTES INTEGER.
+
+      INT1 = TRANSFER(1_I4P, INT1)
+      IS_LITTLE = (INT1(1)==1_I1P)
+      ENDFUNCTION IS_LITTLE_ENDIAN
+   ENDSUBROUTINE CHECK_ENDIAN
+
+   SUBROUTINE PENF_INIT()
+   !< INITIALIZE PENF'S VARIABLES THAT ARE NOT INITIALIZED INTO THE DEFINITION SPECIFICATION.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< CALL PENF_INIT
+   !< PRINT FI1P, BYR4P
+   !<```
+   !=> 4 <<<
+
+   CALL CHECK_ENDIAN
+   BIR16P = BIT_SIZE(MAXR16P) ; BYR16P = BIR16P / 8_I2P
+   BIR8P  = BIT_SIZE(MAXR8P)  ; BYR8P  = BIR8P  / 8_I1P
+   BIR4P  = BIT_SIZE(MAXR4P)  ; BYR4P  = BIR4P  / 8_I1P
+   BIR_P  = BIT_SIZE(MAXR_P)  ; BYR_P  = BIR_P  / 8_I1P
+   IS_INITIALIZED = .TRUE.
+   ENDSUBROUTINE PENF_INIT
+
+   SUBROUTINE PENF_PRINT(UNIT, PREF, IOSTAT, IOMSG)
+   !< PRINT TO THE SPECIFIED UNIT THE PENF'S ENVIRONMENT DATA.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< INTEGER :: U
+   !< OPEN(NEWUNIT=U, STATUS='SCRATCH')
+   !< CALL PENF_PRINT(U)
+   !< CLOSE(U)
+   !< PRINT "(A)", 'DONE'
+   !<```
+   !=> DONE <<<
+   INTEGER(I4P), INTENT(IN)            :: UNIT    !< LOGIC UNIT.
+   CHARACTER(*), INTENT(IN),  OPTIONAL :: PREF    !< PREFIXING STRING.
+   INTEGER(I4P), INTENT(OUT), OPTIONAL :: IOSTAT  !< IO ERROR.
+   CHARACTER(*), INTENT(OUT), OPTIONAL :: IOMSG   !< IO ERROR MESSAGE.
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD   !< PREFIXING STRING.
+   INTEGER(I4P)                        :: IOSTATD !< IO ERROR.
+   CHARACTER(500)                      :: IOMSGD  !< TEMPORARY VARIABLE FOR IO ERROR MESSAGE.
+
+   IF (.NOT.IS_INITIALIZED) CALL PENF_INIT
+   PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
+   IF (ENDIAN==ENDIANL) THEN
+     WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)PREFD//'THIS ARCHITECTURE HAS LITTLE ENDIAN BIT ORDERING'
+   ELSE
+     WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)PREFD//'THIS ARCHITECTURE HAS BIG ENDIAN BIT ORDERING'
+   ENDIF
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'CHARACTER KIND:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  ASCII: '//STR(N=ASCII)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  UCS4:  '//STR(N=UCS4)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  CK:    '//STR(N=CK)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'REALS KIND, FORMAT AND CHARACTERS NUMBER:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R16P: '//STR(N=R16P)//','//FR16P//','//STR(N=DR16P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R8P:  '//STR(N=R8P )//','//FR8P //','//STR(N=DR8P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R4P:  '//STR(N=R4P )//','//FR4P //','//STR(N=DR4P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R_P:  '//STR(N=R_P )//','//FR_P //','//STR(N=DR_P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'IntEGERS KIND, FORMAT AND CHARACTERS NUMBER:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I8P:  '//STR(N=I8P)//','//FI8P //','//STR(N=DI8P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I4P:  '//STR(N=I4P)//','//FI4P //','//STR(N=DI4P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I2P:  '//STR(N=I2P)//','//FI2P //','//STR(N=DI2P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I1P:  '//STR(N=I1P)//','//FI1P //','//STR(N=DI1P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'REALS MINIMUM AND MAXIMUM VALUES:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R16P: '//STR(N=MINR16P)//','//STR(N=MAXR16P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R8P:  '//STR(N=MINR8P )//','//STR(N=MAXR8P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R4P:  '//STR(N=MINR4P )//','//STR(N=MAXR4P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R_P:  '//STR(N=MINR_P )//','//STR(N=MAXR_P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'IntEGERGS MINIMUM AND MAXIMUM VALUES:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I8P:  '//STR(N=MINI8P )//','//STR(N=MAXI8P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I4P:  '//STR(N=MINI4P )//','//STR(N=MAXI4P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I2P:  '//STR(N=MINI2P )//','//STR(N=MAXI2P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I1P:  '//STR(N=MINI1P )//','//STR(N=MAXI1P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'REALS BITS/BYTES SIZES:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R16P: '//STR(N=BIR16P)//'/'//STR(N=BYR16P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R8P:  '//STR(N=BIR8P )//'/'//STR(N=BYR8P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R4P:  '//STR(N=BIR4P )//'/'//STR(N=BYR4P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  R_P:  '//STR(N=BIR_P )//'/'//STR(N=BYR_P )
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'IntEGERS BITS/BYTES SIZES:'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I8P:  '//STR(N=BII8P)//'/'//STR(N=BYI8P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I4P:  '//STR(N=BII4P)//'/'//STR(N=BYI4P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I2P:  '//STR(N=BII2P)//'/'//STR(N=BYI2P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  I1P:  '//STR(N=BII1P)//'/'//STR(N=BYI1P)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'SMALLEST REALS'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  SMALLR16P: '//STR(SMALLR16P, .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  SMALLR8P:  '//STR(SMALLR8P,  .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  SMALLR4P:  '//STR(SMALLR4P,  .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  SMALLR_P:  '//STR(SMALLR_P,  .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'MACHINE ZERO'
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  ZEROR16P: '//STR(ZEROR16P, .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  ZEROR8P:  '//STR(ZEROR8P,  .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  ZEROR4P:  '//STR(ZEROR4P,  .TRUE.)
+   WRITE(UNIT=UNIT,FMT='(A)',IOSTAT=IOSTATD,IOMSG=IOMSGD)  PREFD//'  ZEROR_P:  '//STR(ZEROR_P,  .TRUE.)
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD
+   IF (PRESENT(IOMSG))  IOMSG  = IOMSGD
+   ENDSUBROUTINE PENF_PRINT
+
+   ! PRIVATE PROCEDURES
+   ELEMENTAL FUNCTION DIGIT_I8(N) RESULT(DIGIT)
+   !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, DIGIT(100_I8P)
+   !<```
+   !=> 3 <<<
+   INTEGER(I8P), INTENT(IN) :: N     !< INPUT INTEGER.
+   CHARACTER(DI8P)          :: STR   !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+   INTEGER(I4P)             :: DIGIT !< NUMBER OF DIGITS.
+
+   WRITE(STR, FI8P) ABS(N)        ! CASTING OF N TO STRING.
+   DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N.
+   ENDFUNCTION DIGIT_I8
+
+   ELEMENTAL FUNCTION DIGIT_I4(N) RESULT(DIGIT)
+   !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, DIGIT(100_I4P)
+   !<```
+   !=> 3 <<<
+   INTEGER(I4P), INTENT(IN) :: N     !< INPUT INTEGER.
+   CHARACTER(DI4P)          :: STR   !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+   INTEGER(I4P)             :: DIGIT !< NUMBER OF DIGITS.
+
+   WRITE(STR, FI4P) ABS(N)        ! CASTING OF N TO STRING.
+   DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N.
+   ENDFUNCTION DIGIT_I4
+
+   ELEMENTAL FUNCTION DIGIT_I2(N) RESULT(DIGIT)
+   !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, DIGIT(100_I2P)
+   !<```
+   !=> 3 <<<
+   INTEGER(I2P), INTENT(IN) :: N     !< INPUT INTEGER.
+   CHARACTER(DI2P)          :: STR   !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+   INTEGER(I4P)             :: DIGIT !< NUMBER OF DIGITS.
+
+   WRITE(STR, FI2P) ABS(N)        ! CASTING OF N TO STRING.
+   DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N.
+   ENDFUNCTION DIGIT_I2
+
+   ELEMENTAL FUNCTION DIGIT_I1(N) RESULT(DIGIT)
+   !< COMPUTE THE NUMBER OF DIGITS IN DECIMAL BASE OF THE INPUT INTEGER.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< PRINT FI4P, DIGIT(100_I1P)
+   !<```
+   !=> 3 <<<
+   INTEGER(I1P), INTENT(IN) :: N     !< INPUT INTEGER.
+   CHARACTER(DI1P)          :: STR   !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
+   INTEGER(I4P)             :: DIGIT !< NUMBER OF DIGITS.
+
+   WRITE(STR, FI1P) ABS(N)        ! CASTING OF N TO STRING.
+   DIGIT = LEN_TRIM(ADJUSTL(STR)) ! CALCULATING THE DIGITS NUMBER OF N.
+   ENDFUNCTION DIGIT_I1
+ENDMODULE PENF
+
+
+
+
+
+
+
+!< KISS LIBRARY FOR PACKING HETEROGENEOUS DATA INTO SINGLE (HOMOGENEOUS) PACKED ONE.
+!
+MODULE BEFOR64_PACK_DATA_M
+!< KISS LIBRARY FOR PACKING HETEROGENEOUS DATA INTO SINGLE (HOMOGENEOUS) PACKED ONE.
+USE PENF
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: PACK_DATA
+
+INTERFACE PACK_DATA
+  !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+  !<
+  !< THIS IS USEFUL FOR ENCODING DIFFERENT (HETEROGENEOUS) KINDS VARIABLES INTO A SINGLE (HOMOGENEOUS) STREAM OF BITS.
+  !< @NOTE THIS PROCEDURE EXPLOITS THE `TRANSFER` BUILTIN FUNCTION, THAT FROM THE STANDARD (2003+) IS DEFINED AS
+  !< `TRANSFER(SOURCE, MOLD [, SIZE])`. DATA OBJECT HAVING A PHYSICAL REPRESENTATION IDENTICAL TO THAT OF `SOURCE` BUT WITH THE TYPE
+  !< AND TYPE PARAMETERS OF `MOLD`. THE RESULT IS OF THE SAME TYPE AND TYPE PARAMETERS AS `MOLD`.
+  !< IF `MOLD` IS AN ARRAY AND `SIZE` IS ABSENT, THE RESULT IS AN ARRAY AND OF RANK ONE. ITS SIZE IS AS SMALL AS POSSIBLE SUCH
+  !< THAT ITS PHYSICAL REPRESENTATION IS NOT SHORTER THAN THAT OF `SOURCE`.
+  !<
+  !< PRESENTLY, THE FOLLOWING COMBINATIONS ARE AVAILABLE:
+  !<
+  !<* [ ] ARRAYS-ARRAYS:
+  !<    * [X] REAL(ANY)-REAL(ANY);
+  !<    * [X] REAL(ANY)-INTEGER(ANY);
+  !<    * [X] INTEGER(ANY)-INTEGER(ANY);
+  !<    * [X] INTEGER(ANY)-REAL(ANY);
+  !<    * [ ] REAL(ANY)-CHARACTER;
+  !<    * [ ] CHARACTER-REAL(ANY);
+  !<    * [ ] INTEGER(ANY)-CHARACTER;
+  !<    * [ ] CHARACTER-INTEGER(ANY);
+  !<* [ ] SCALARS-SCALARS:
+  !<    * [ ] REAL(ANY)-REAL(ANY);
+  !<    * [ ] REAL(ANY)-INTEGER(ANY);
+  !<    * [ ] INTEGER(ANY)-INTEGER(ANY);
+  !<    * [ ] INTEGER(ANY)-REAL(ANY);
+  !<    * [ ] REAL(ANY)-CHARACTER;
+  !<    * [ ] CHARACTER-REAL(ANY);
+  !<    * [ ] INTEGER(ANY)-CHARACTER;
+  !<    * [ ] CHARACTER-INTEGER(ANY);
+  !<
+  !<### EXAMPLES OF USAGE
+  !<
+  !<#### PACKING TWO REAL ARRAYS, ONE WITH KIND R8P AND ONE WITH R4P
+  !<```ORTRAN
+  !<REAL(R8P)::                 ARRAY_R8(1:12)
+  !<REAL(R4P)::                 ARRAY_R4(-1:5)
+  !<INTEGER(I1P), ALLOCATABLE:: RPACK
+  !<...
+  !<CALL PACK_DATA(A1=ARRAY_R8,A2=ARRAY_R4,PACKED=RPACK)
+  !<```
+  !<#### PACKING TWO ARRAYS, ONE REAL WITH KIND R4P AND ONE INTEGER WITH I4P
+  !<```ORTRAN
+  !<REAL(R4P)::                 ARRAY_R4(2)
+  !<INTEGER(I4P)::              ARRAY_I4(0:2)
+  !<INTEGER(I1P), ALLOCATABLE:: RPACK
+  !<...
+  !<CALL PACK_DATA(A1=ARRAY_R4,A2=ARRAY_I4,PACKED=RPACK)
+  !<```
+  MODULE PROCEDURE PACK_DATA_R8_R4, PACK_DATA_R8_I8, PACK_DATA_R8_I4, PACK_DATA_R8_I2, PACK_DATA_R8_I1, &
+                   PACK_DATA_R4_R8, PACK_DATA_R4_I8, PACK_DATA_R4_I4, PACK_DATA_R4_I2, PACK_DATA_R4_I1, &
+                   PACK_DATA_I8_R8, PACK_DATA_I8_R4, PACK_DATA_I8_I4, PACK_DATA_I8_I2, PACK_DATA_I8_I1, &
+                   PACK_DATA_I4_R8, PACK_DATA_I4_R4, PACK_DATA_I4_I8, PACK_DATA_I4_I2, PACK_DATA_I4_I1, &
+                   PACK_DATA_I2_R8, PACK_DATA_I2_R4, PACK_DATA_I2_I8, PACK_DATA_I2_I4, PACK_DATA_I2_I1, &
+                   PACK_DATA_I1_R8, PACK_DATA_I1_R4, PACK_DATA_I1_I8, PACK_DATA_I1_I4, PACK_DATA_I1_I2
+ENDINTERFACE
+
+CONTAINS
+   PURE SUBROUTINE PACK_DATA_R8_R4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P)                 :: A1(1)
+   !< REAL(R4P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   REAL(R8P),                 INTENT(IN)    :: A1(1:)    !< FIRS DATA STREAM.
+   REAL(R4P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R8_R4
+
+   PURE SUBROUTINE PACK_DATA_R8_I8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P)                 :: A1(1)
+   !< INTEGER(I8P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   REAL(R8P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I8P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R8_I8
+
+   PURE SUBROUTINE PACK_DATA_R8_I4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P)                 :: A1(1)
+   !< INTEGER(I4P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   REAL(R8P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I4P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R8_I4
+
+   PURE SUBROUTINE PACK_DATA_R8_I2(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P)                 :: A1(1)
+   !< INTEGER(I2P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   REAL(R8P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I2P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R8_I2
+
+   PURE SUBROUTINE PACK_DATA_R8_I1(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P)                 :: A1(1)
+   !< INTEGER(I1P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   REAL(R8P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I1P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R8_I1
+
+   PURE SUBROUTINE PACK_DATA_R4_R8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P)                 :: A1(1)
+   !< REAL(R8P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   REAL(R4P),                 INTENT(IN)    :: A1(1:)    !< FIRS DATA STREAM.
+   REAL(R8P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R4_R8
+
+   PURE SUBROUTINE PACK_DATA_R4_I8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P)                 :: A1(1)
+   !< INTEGER(I8P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   REAL(R4P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I8P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R4_I8
+
+   PURE SUBROUTINE PACK_DATA_R4_I4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P)                 :: A1(1)
+   !< INTEGER(I4P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   REAL(R4P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I4P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R4_I4
+
+   PURE SUBROUTINE PACK_DATA_R4_I2(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P)                 :: A1(1)
+   !< INTEGER(I2P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   REAL(R4P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I2P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R4_I2
+
+   PURE SUBROUTINE PACK_DATA_R4_I1(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P)                 :: A1(1)
+   !< INTEGER(I1P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   REAL(R4P),                 INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I1P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_R4_I1
+
+   PURE SUBROUTINE PACK_DATA_I8_R8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P)              :: A1(1)
+   !< REAL(R8P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I8P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R8P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I8_R8
+
+   PURE SUBROUTINE PACK_DATA_I8_R4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P)              :: A1(1)
+   !< REAL(R4P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I8P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R4P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I8_R4
+
+   PURE SUBROUTINE PACK_DATA_I8_I4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P)              :: A1(1)
+   !< INTEGER(I4P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   INTEGER(I8P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I4P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I8_I4
+
+   PURE SUBROUTINE PACK_DATA_I8_I2(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P)              :: A1(1)
+   !< INTEGER(I2P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   INTEGER(I8P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I2P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I8_I2
+
+   PURE SUBROUTINE PACK_DATA_I8_I1(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P)              :: A1(1)
+   !< INTEGER(I1P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(9)
+   !<```
+   !=> 1 <<<
+   INTEGER(I8P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I1P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I8_I1
+
+   PURE SUBROUTINE PACK_DATA_I4_R8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P)              :: A1(1)
+   !< REAL(R8P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I4P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R8P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I4_R8
+
+   PURE SUBROUTINE PACK_DATA_I4_R4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P)              :: A1(1)
+   !< REAL(R4P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I4P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R4P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I4_R4
+
+   PURE SUBROUTINE PACK_DATA_I4_I8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P)              :: A1(1)
+   !< INTEGER(I8P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   INTEGER(I4P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I8P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I4_I8
+
+   PURE SUBROUTINE PACK_DATA_I4_I2(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P)              :: A1(1)
+   !< INTEGER(I2P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   INTEGER(I4P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I2P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I4_I2
+
+   PURE SUBROUTINE PACK_DATA_I4_I1(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P)              :: A1(1)
+   !< INTEGER(I1P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(5)
+   !<```
+   !=> 1 <<<
+   INTEGER(I4P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I1P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I4_I1
+
+   PURE SUBROUTINE PACK_DATA_I2_R8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P)              :: A1(1)
+   !< REAL(R8P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I2P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R8P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I2_R8
+
+   PURE SUBROUTINE PACK_DATA_I2_R4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P)              :: A1(1)
+   !< REAL(R4P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I2P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R4P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I2_R4
+
+   PURE SUBROUTINE PACK_DATA_I2_I8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P)              :: A1(1)
+   !< INTEGER(I8P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(3)
+   !<```
+   !=> 1 <<<
+   INTEGER(I2P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I8P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I2_I8
+
+   PURE SUBROUTINE PACK_DATA_I2_I4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P)              :: A1(1)
+   !< INTEGER(I4P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(3)
+   !<```
+   !=> 1 <<<
+   INTEGER(I2P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I4P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I2_I4
+
+   PURE SUBROUTINE PACK_DATA_I2_I1(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P)              :: A1(1)
+   !< INTEGER(I1P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(3)
+   !<```
+   !=> 1 <<<
+   INTEGER(I2P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I1P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I2_I1
+
+   PURE SUBROUTINE PACK_DATA_I1_R8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P)              :: A1(1)
+   !< REAL(R8P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I1P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R8P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I1_R8
+
+   PURE SUBROUTINE PACK_DATA_I1_R4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P)              :: A1(1)
+   !< REAL(R4P)                 :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(SIZE(PACK, DIM=1))
+   !<```
+   !=> 63 <<<
+   INTEGER(I1P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   REAL(R4P),                 INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I1_R4
+
+   PURE SUBROUTINE PACK_DATA_I1_I8(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P)              :: A1(1)
+   !< INTEGER(I8P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(2)
+   !<```
+   !=> 1 <<<
+   INTEGER(I1P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I8P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I1_I8
+
+   PURE SUBROUTINE PACK_DATA_I1_I4(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P)              :: A1(1)
+   !< INTEGER(I4P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(2)
+   !<```
+   !=> 1 <<<
+   INTEGER(I1P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I4P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I1_I4
+
+   PURE SUBROUTINE PACK_DATA_I1_I2(A1, A2, PACKED)
+   !< PACK DIFFERENT KINDS OF DATA INTO SINGLE I1P ARRAY.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P)              :: A1(1)
+   !< INTEGER(I2P)              :: A2(1)
+   !< INTEGER(I1P), ALLOCATABLE :: PACK(:)
+   !< A1(1) = 0
+   !< A2(1) = 1
+   !< CALL PACK_DATA(A1=A1, A2=A2, PACKED=PACK)
+   !< PRINT *, PACK(2)
+   !<```
+   !=> 1 <<<
+   INTEGER(I1P),              INTENT(IN)    :: A1(1:)    !< FIRST DATA STREAM.
+   INTEGER(I2P),              INTENT(IN)    :: A2(1:)    !< SECOND DATA STREAM.
+   INTEGER(I1P), ALLOCATABLE, INTENT(INOUT) :: PACKED(:) !< PACKED DATA INTO I1P ARRAY.
+   INTEGER(I1P), ALLOCATABLE                :: P1(:)     !< TEMPORARY PACKED DATA OF FIRST STREAM.
+   INTEGER(I1P), ALLOCATABLE                :: P2(:)     !< TEMPORARY PACKED DATA OF SECOND STREAM.
+
+   P1 = TRANSFER(A1,P1)
+   P2 = TRANSFER(A2,P2)
+   PACKED = [P1,P2]
+   ENDSUBROUTINE PACK_DATA_I1_I2
+ENDMODULE BEFOR64_PACK_DATA_M
+
+
+
+!< BEFOR64, BASE64 ENCODING/DECODING LIBRARY FOR FORTRAN POOR PEOPLE.
+
+MODULE BEFOR64
+!< BEFOR64, BASE64 ENCODING/DECODING LIBRARY FOR FORTRAN POOR PEOPLE.
+USE PENF
+USE BEFOR64_PACK_DATA_M
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: IS_B64_INITIALIZED, B64_INIT
+PUBLIC :: B64_ENCODE, B64_ENCODE_UP
+PUBLIC :: B64_DECODE, B64_DECODE_UP
+PUBLIC :: PACK_DATA
+
+LOGICAL       :: IS_B64_INITIALIZED=.FALSE. !< FLAG FOR CHECKING THE INITIALIZATION OF THE LIBRARY.
+CHARACTER(64) :: BASE64="ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/" !< BASE64 ALPHABET.
+
+INTERFACE B64_ENCODE
+  !< ENCODE NUMBERS (INTEGER AND REAL) TO BASE64.
+  !<
+  !< THIS IS AN INTERFACE FOR ENCODING INTEGER AND REAL NUMBERS OF ANY KINDS INTO A BASE64 STRING. THIS INTERFACE CAN ENCODE BOTH
+  !< SCALAR AND ARRAY.
+  !<
+  !< @WARNING THE ENCODED STRING IS RETURNED AS VARYING LENGTH CHARACTER STRING, `CHARACTER(LEN=:), ALLOCATABLE:: STRING`, THUS THE
+  !< COMPILER MUST SUPPORT SUCH A FORTRAN (2003) FEATURE.
+  !<
+  !< @NOTE BEFORE START TO ENCODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE
+  !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION.
+  !<
+  !<### USAGE
+  !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE.
+  !<
+  !<#### SCALAR ENCODING
+  !<```ORTRAN
+  !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING
+  !<...
+  !<CALL B64_ENCODE(N=12._R8P,CODE=CODE64)
+  !<```
+  !<
+  !<#### ARRAY ENCODING
+  !<```ORTRAN
+  !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING
+  !<...
+  !<CALL B64_ENCODE(N=[12_I4P,1_I4P],CODE=CODE64)
+  !<```
+  !<
+  !< @NOTE IF YOU WANT TO ENCODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA`
+  !< PROCEDURE.
+  !<
+  !< @WARNING THE ENCODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH.
+  MODULE PROCEDURE &
+#if defined _R16P
+                   B64_ENCODE_R16,    B64_ENCODE_R16_A, &
+#endif
+                   B64_ENCODE_R8,     B64_ENCODE_R8_A,  &
+                   B64_ENCODE_R4,     B64_ENCODE_R4_A,  &
+                   B64_ENCODE_I8,     B64_ENCODE_I8_A,  &
+                   B64_ENCODE_I4,     B64_ENCODE_I4_A,  &
+                   B64_ENCODE_I2,     B64_ENCODE_I2_A,  &
+                   B64_ENCODE_I1,     B64_ENCODE_I1_A,  &
+                   B64_ENCODE_STRING, B64_ENCODE_STRING_A
+ENDINTERFACE
+
+INTERFACE B64_ENCODE_UP
+  !< ENCODE UNLIMITED POLYMORPHIC VARIABLE TO BASE64.
+  !<
+  !< THIS IS AN INTERFACE FOR ENCODING BOTH SCALAR AND ARRAY.
+  !<
+  !< @WARNING THE ENCODED STRING IS RETURNED AS VARYING LENGTH CHARACTER STRING, `CHARACTER(LEN=:), ALLOCATABLE:: STRING`, THUS THE
+  !< COMPILER MUST SUPPORT SUCH A FORTRAN (2003) FEATURE.
+  !<
+  !< @NOTE BEFORE START TO ENCODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE
+  !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION.
+  !<
+  !<### USAGE
+  !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE.
+  !<
+  !<#### SCALAR ENCODING
+  !<```ORTRAN
+  !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING
+  !<...
+  !<CALL B64_ENCODE_UP(UP=12._R8P,CODE=CODE64)
+  !<```
+  !<
+  !<#### ARRAY ENCODING
+  !<```ORTRAN
+  !<CHARACTER(LEN=:), ALLOCATABLE:: CODE64 ! BASE64 ENCODED STRING
+  !<...
+  !<CALL B64_ENCODE_UP(UP=[12_I4P,1_I4P],CODE=CODE64)
+  !<```
+  !<
+  !< @NOTE IF YOU WANT TO ENCODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA`
+  !< PROCEDURE.
+  !<
+  !< @WARNING THE ENCODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH.
+  MODULE PROCEDURE B64_ENCODE_UP, B64_ENCODE_UP_A
+ENDINTERFACE
+
+INTERFACE B64_DECODE
+  !< DECODE NUMBERS (INTEGER AND REAL) FROM BASE64.
+  !<
+  !< THIS IS AN INTERFACE FOR DECODING INTEGER AND REAL NUMBERS OF ANY KINDS FROM A BASE64 STRING. THIS INTERFACE CAN DECODE BOTH
+  !< SCALAR AND ARRAY.
+  !<
+  !< @NOTE BEFORE START TO DECODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE
+  !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION.
+  !<
+  !<### USAGE
+  !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE.
+  !<
+  !<#### SCALAR DECODING
+  !<```ORTRAN
+  !<REAL(R8P):: DECODED ! SCALAR TO BE DECODED
+  !<...
+  !<CALL B64_DECODE(CODE='AAAAAAAA8D8=',N=DECODED)
+  !<```
+  !<
+  !<#### ARRAY DECODING
+  !<```ORTRAN
+  !<INTEGER(I8P):: DECODED(1:4) ! ARRAY TO BE DECODED
+  !<...
+  !<CALL B64_DECODE(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',N=DECODED)
+  !<```
+  !<
+  !< @NOTE IF YOU WANT TO DECODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA`
+  !< PROCEDURE.
+  !<
+  !< @WARNING THE DECODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH.
+  MODULE PROCEDURE &
+#if defined _R16P
+                   B64_DECODE_R16,    B64_DECODE_R16_A, &
+#endif
+                   B64_DECODE_R8,     B64_DECODE_R8_A,  &
+                   B64_DECODE_R4,     B64_DECODE_R4_A,  &
+                   B64_DECODE_I8,     B64_DECODE_I8_A,  &
+                   B64_DECODE_I4,     B64_DECODE_I4_A,  &
+                   B64_DECODE_I2,     B64_DECODE_I2_A,  &
+                   B64_DECODE_I1,     B64_DECODE_I1_A,  &
+                   B64_DECODE_STRING, B64_DECODE_STRING_A
+ENDINTERFACE
+
+INTERFACE B64_DECODE_UP
+  !< DECODE UNLIMITED POLYMORPHIC VARIABLE FROM BASE64.
+  !<
+  !< THIS IS AN INTERFACE FOR DECODING BOTH SCALAR AND ARRAY.
+  !<
+  !< @NOTE BEFORE START TO DECODE ANYTHING THE LIBRARY MUST BE INITIALIZED. THE PROCEDURE `B64_INIT` MUST BE CALLED AT FIRST. THE
+  !< GLOBAL VARIABLE `IS_B64_INITIALIZED` CAN BE USED TO CHECK THE STATUS OF THE INITIALIZATION.
+  !<
+  !<### USAGE
+  !< FOR A PRACTICAL EXAMPLE SEE THE `AUTOTEST` PROCEDURE.
+  !<
+  !<#### SCALAR DECODING
+  !<```ORTRAN
+  !<REAL(R8P):: DECODED ! SCALAR TO BE DECODED
+  !<...
+  !<CALL B64_DECODE_UP(CODE='AAAAAAAA8D8=',UP=DECODED)
+  !<```
+  !<
+  !<#### ARRAY DECODING
+  !<```ORTRAN
+  !<INTEGER(I8P):: DECODED(1:4) ! ARRAY TO BE DECODED
+  !<...
+  !<CALL B64_DECODE_UP(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',UP=DECODED)
+  !<```
+  !<
+  !< @NOTE IF YOU WANT TO DECODE HETEROGENOUS DATA (E.G. INTEGER AND REAL NUMBERS), YOU MUST USE THE AUXILIARY `PACK_DATA`
+  !< PROCEDURE.
+  !<
+  !< @WARNING THE DECODING OF ARRAY OF STRINGS IS ADMITTED ONLY IF EACH STRING OF THE ARRAY HAS THE SAME LENGTH.
+  MODULE PROCEDURE B64_DECODE_UP, B64_DECODE_UP_A
+ENDINTERFACE
+
+CONTAINS
+   SUBROUTINE B64_INIT()
+   !< INITIALIZE THE BEFOR64 LIBRARY.
+   !<
+   !< @NOTE THIS PROCEDURE **MUST** BE CALLED BEFORE ENCODING/DECODING ANYTHING!
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< CALL B64_INIT
+   !< PRINT "(L1)", IS_B64_INITIALIZED
+   !<```
+   !=> T <<<
+
+   IF (.NOT.IS_INITIALIZED) CALL PENF_INIT
+   IS_B64_INITIALIZED = .TRUE.
+   ENDSUBROUTINE B64_INIT
+
+   PURE SUBROUTINE ENCODE_BITS(BITS, PADD, CODE)
+   !< ENCODE A BITS STREAM (MUST BE MULTIPLE OF 24 BITS) INTO BASE64 CHARCATERS CODE (OF LENGTH MULTIPLE OF 4).
+   !<
+   !< THE BITS STREAM ARE ENCODED IN CHUNKS OF 24 BITS AS THE FOLLOWING EXAMPLE (IN LITTLE ENDIAN ORDER)
+   !<```
+   !< +--FIRST OCTET--+-SECOND OCTET--+--THIRD OCTET--+
+   !< |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
+   !< +-----------+---+-------+-------+---+-----------+
+   !< |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|
+   !< +--1.INDEX--+--2.INDEX--+--3.INDEX--+--4.INDEX--+
+   !<```
+   !< @NOTE THE 4 INDEXES ARE STORED INTO 4 ELEMENTS 8 BITS ARRAY, THUS 2 BITS OF EACH ARRAY ELEMENT ARE NOT USED.
+   !<
+   !< @NOTE THE NUMBER OF PADDINGS MUST BE COMPUTED OUTSIDE THIS PROCEDURE, INTO THE CALLING SCOPE.
+   !<
+   !< @WARNING THIS PROCEDURE IS THE BACKEND OF ENCODING, THUS IT MUST BE NEVER CALLED OUTSIDE THE MODULE.
+   INTEGER(I1P), INTENT(IN)  :: BITS(1:)  !< BITS TO BE ENCODED.
+   INTEGER(I4P), INTENT(IN)  :: PADD      !< NUMBER OF PADDING CHARACTERS ('=').
+   CHARACTER(*), INTENT(OUT) :: CODE      !< CHARACTERS CODE.
+   INTEGER(I1P)              :: SIXB(1:4) !< 6 BITS SLICES (STORED INTO 8 BITS INTEGER) OF 24 BITS INPUT.
+   INTEGER(I8P)              :: C         !< COUNTER.
+   INTEGER(I8P)              :: E         !< COUNTER.
+   INTEGER(I8P)              :: NB        !< LENGTH OF BITS ARRAY.
+
+   NB=SIZE(BITS,DIM=1,KIND=I8P)
+   C = 1_I8P
+   DO E=1_I8P,NB,3_I8P ! LOOP OVER ARRAY ELEMENTS: 3 BYTES (24 BITS) SCANNING
+      SIXB = 0_I1P
+         CALL MVBITS(BITS(E  ),2,6,SIXB(1),0)
+         CALL MVBITS(BITS(E  ),0,2,SIXB(2),4)
+      IF (E+1<=NB) THEN
+         CALL MVBITS(BITS(E+1),4,4,SIXB(2),0)
+         CALL MVBITS(BITS(E+1),0,4,SIXB(3),2)
+      ENDIF
+      IF (E+2<=NB) THEN
+         CALL MVBITS(BITS(E+2),6,2,SIXB(3),0)
+         CALL MVBITS(BITS(E+2),0,6,SIXB(4),0)
+      ENDIF
+      SIXB = SIXB + 1_I1P
+      CODE(C  :C  ) = BASE64(SIXB(1):SIXB(1))
+      CODE(C+1:C+1) = BASE64(SIXB(2):SIXB(2))
+      CODE(C+2:C+2) = BASE64(SIXB(3):SIXB(3))
+      CODE(C+3:C+3) = BASE64(SIXB(4):SIXB(4))
+      C = C + 4_I8P
+   ENDDO
+   IF (PADD>0) CODE(LEN(CODE)-PADD+1:)=REPEAT('=',PADD)
+   ENDSUBROUTINE ENCODE_BITS
+
+   PURE SUBROUTINE DECODE_BITS(CODE, BITS)
+   !< DECODE A BASE64 STRING INTO A SEQUENCE OF BITS STREAM.
+   !<
+   !< THE BASE64 STRING MUST BE PARSED WITH A STRIKE OF 4 CHARACTERS AND CONVERTED INTO A 3 BYTES STREAM. CONSIDERING THE BASE64 CODE
+   !< `QUJD` THE DECODING PROCESS MUST DO
+   !<```
+   !< +-B64 CHAR--+-B64 CHAR--+-B64 CHAR--+-B64 CHAR--+
+   !< |      Q    |      U    |      J    |      D    |
+   !< +-B64 INDEX-+-B64 INDEX-+-B64 INDEX-+-B64 INDEX-+
+   !< !      16   |      20   |      9    |      3    |
+   !< +-6 BITS----+-6 BITS----+-6 BITS----+-6 BITS----+
+   !< |0 1 0 0 0 0|0 1 0 1 0 0|0 0 1 0 0 1|0 0 0 0 1 1|
+   !< +-----------+---+-------+-------+---+-----------+
+   !< |0 1 0 0 0 0 0 1|0 1 0 0 0 0 1 0|0 1 0 0 0 0 1 1|
+   !< +-----8 BITS----+-----8 BITS----+-----8 BITS----+
+   !<```
+   !< @NOTE THE BITS PATTERN IS RETURNED AS A 1-BYTE ELEMENT ARRAY, THE DIMENSION OF WITCH MUST BE COMPUTED OUTSIDE THIS PROCEDURE.
+   !<
+   !< @WARNING THIS PROCEDURE IS THE BACKEND OF DECODING, THUS IT MUST BE NEVER CALLED OUTSIDE THE MODULE.
+   CHARACTER(*), INTENT(IN)  :: CODE      !< CHARACTERS CODE.
+   INTEGER(I1P), INTENT(OUT) :: BITS(1:)  !< BITS DECODED.
+   INTEGER(I1P)              :: SIXB(1:4) !< 6 BITS SLICES (STORED INTO 8 BITS INTEGER) OF 24 BITS INPUT.
+   INTEGER(I8P)              :: C         !< COUNTER.
+   INTEGER(I8P)              :: E         !< COUNTER.
+   INTEGER(I8P)              :: NB        !< LENGTH OF BITS ARRAY.
+
+   NB=SIZE(BITS,DIM=1,KIND=I8P)
+   E = 1_I8P
+   DO C=1_I8P,LEN(CODE),4_I8P ! LOOP OVER CODE CHARACTERS: 3 BYTES (24 BITS) SCANNING
+      SIXB = 0_I1P
+      SIXB(1) = INDEX(BASE64,CODE(C  :C  )) - 1
+      SIXB(2) = INDEX(BASE64,CODE(C+1:C+1)) - 1
+      SIXB(3) = INDEX(BASE64,CODE(C+2:C+2)) - 1
+      SIXB(4) = INDEX(BASE64,CODE(C+3:C+3)) - 1
+         CALL MVBITS(SIXB(1),0,6,BITS(E  ),2) ; CALL MVBITS(SIXB(2),4,2,BITS(E  ),0)
+      IF (E+1<=NB) THEN
+         CALL MVBITS(SIXB(2),0,4,BITS(E+1),4) ; CALL MVBITS(SIXB(3),2,4,BITS(E+1),0)
+      ENDIF
+      IF (E+2<=NB) THEN
+         CALL MVBITS(SIXB(3),0,2,BITS(E+2),6) ; CALL MVBITS(SIXB(4),0,6,BITS(E+2),0)
+      ENDIF
+      E = E + 3_I8P
+   ENDDO
+   ENDSUBROUTINE DECODE_BITS
+
+   SUBROUTINE B64_ENCODE_UP(UP, CODE)
+   !< ENCODE AN UNLIMITED POLYMORPHIC SCALAR TO BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE_UP(UP=1._R8P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAAAA8D8= <<<
+   CLASS(*),                      INTENT(IN)  :: UP   !< UNLIMITED POLYMORPHIC VARIABLE TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE !< ENCODED SCALAR.
+
+   SELECT TYPE(UP)
+   TYPE IS(REAL(R8P))
+      CALL B64_ENCODE_R8(N=UP,CODE=CODE)
+   TYPE IS(REAL(R4P))
+      CALL B64_ENCODE_R4(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I8P))
+      CALL B64_ENCODE_I8(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I4P))
+      CALL B64_ENCODE_I4(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I2P))
+      CALL B64_ENCODE_I2(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I1P))
+      CALL B64_ENCODE_I1(N=UP,CODE=CODE)
+   TYPE IS(CHARACTER(*))
+      CALL B64_ENCODE_STRING(S=UP,CODE=CODE)
+   ENDSELECT
+   ENDSUBROUTINE B64_ENCODE_UP
+
+   PURE SUBROUTINE B64_ENCODE_UP_A(UP, CODE)
+   !< ENCODE AN UNLIMITED POLYMORPHIC ARRAY TO BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE_UP(UP=[0._R4P,-32.12_R4P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAOF6AMI= <<<
+   CLASS(*),                      INTENT(IN)  :: UP(1:) !< UNLIMITED POLYMORPHIC VARIABLE TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE   !< ENCODED ARRAY.
+
+   SELECT TYPE(UP)
+   TYPE IS(REAL(R8P))
+      CALL B64_ENCODE_R8_A(N=UP,CODE=CODE)
+   TYPE IS(REAL(R4P))
+      CALL B64_ENCODE_R4_A(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I8P))
+      CALL B64_ENCODE_I8_A(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I4P))
+      CALL B64_ENCODE_I4_A(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I2P))
+      CALL B64_ENCODE_I2_A(N=UP,CODE=CODE)
+   TYPE IS(INTEGER(I1P))
+      CALL B64_ENCODE_I1_A(N=UP,CODE=CODE)
+   TYPE IS(CHARACTER(*))
+      CALL B64_ENCODE_STRING_A(S=UP,CODE=CODE)
+   ENDSELECT
+   ENDSUBROUTINE B64_ENCODE_UP_A
+
+   SUBROUTINE B64_DECODE_UP(CODE, UP)
+   !< DECODE AN UNLIMITED POLYMORPHIC SCALAR FROM BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P) :: SCALAR_I4
+   !< CALL B64_DECODE_UP(CODE='5WCAAA==',UP=SCALAR_I4)
+   !< PRINT "(L1)", SCALAR_I4==2023_I4P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE !< ENCODED SCALAR.
+   CLASS(*),     INTENT(OUT) :: UP   !< UNLIMITED POLYMORPHIC VARIABLE TO BE DECODED.
+
+   SELECT TYPE(UP)
+   TYPE IS(REAL(R8P))
+      CALL B64_DECODE_R8(CODE=CODE,N=UP)
+   TYPE IS(REAL(R4P))
+      CALL B64_DECODE_R4(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I8P))
+      CALL B64_DECODE_I8(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I4P))
+      CALL B64_DECODE_I4(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I2P))
+      CALL B64_DECODE_I2(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I1P))
+      CALL B64_DECODE_I1(CODE=CODE,N=UP)
+   TYPE IS(CHARACTER(*))
+      CALL B64_DECODE_STRING(CODE=CODE,S=UP)
+   ENDSELECT
+   ENDSUBROUTINE B64_DECODE_UP
+
+   SUBROUTINE B64_DECODE_UP_A(CODE, UP)
+   !< DECODE AN UNLIMITED POLYMORPHIC ARRAY FROM BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P) :: ARRAY_I8(1:4)
+   !< CALL B64_DECODE_UP(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=', UP=ARRAY_I8)
+   !< PRINT "(L1)", STR(N=ARRAY_I8)==STR(N=[23_I8P,324_I8P,25456656_I8P,2_I8P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE   !< ENCODED ARRAY.
+   CLASS(*),     INTENT(OUT) :: UP(1:) !< UNLIMITED POLYMORPHIC VARIABLE TO BE DECODED.
+
+   SELECT TYPE(UP)
+   TYPE IS(REAL(R8P))
+      CALL B64_DECODE_R8_A(CODE=CODE,N=UP)
+   TYPE IS(REAL(R4P))
+      CALL B64_DECODE_R4_A(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I8P))
+      CALL B64_DECODE_I8_A(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I4P))
+      CALL B64_DECODE_I4_A(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I2P))
+      CALL B64_DECODE_I2_A(CODE=CODE,N=UP)
+   TYPE IS(INTEGER(I1P))
+      CALL B64_DECODE_I1_A(CODE=CODE,N=UP)
+   TYPE IS(CHARACTER(*))
+      CALL B64_DECODE_STRING_A(CODE=CODE,S=UP)
+   ENDSELECT
+   ENDSUBROUTINE B64_DECODE_UP_A
+
+   PURE SUBROUTINE B64_ENCODE_R16(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (R16P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=134.231_R16P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> CKWCWMTHYEA= <<<
+   REAL(R16P),                    INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYR16P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYR16P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+#if defined _R16P
+   PADD = MOD((BYR16P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+#else
+   PADD = MOD((BYR16P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   ! johodges Edited from 3_I1P to 3_I2P
+#endif
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R16
+
+   PURE SUBROUTINE B64_ENCODE_R8(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (R8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=1._R8P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAAAA8D8= <<<
+   REAL(R8P),                     INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYR8P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYR8P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYR8P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R8
+
+   PURE SUBROUTINE B64_ENCODE_R4(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (R4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=0._R4P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAA== <<<
+   REAL(R4P),                     INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYR4P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYR4P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYR4P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R4
+
+   PURE SUBROUTINE B64_ENCODE_I8(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (I8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=23_I8P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> FWAAAAAAAAA= <<<
+   INTEGER(I8P),                  INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYI8P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYI8P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYI8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I8
+
+   PURE SUBROUTINE B64_ENCODE_I4(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (I4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=2023_I4P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> 5WCAAA== <<<
+   INTEGER(I4P),                  INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYI4P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYI4P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYI4P),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I4
+
+   PURE SUBROUTINE B64_ENCODE_I2(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (I2P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=-203_I2P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> NF8= <<<
+   INTEGER(I2P),                  INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYI2P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYI2P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYI2P),3_I2P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I2
+
+   PURE SUBROUTINE B64_ENCODE_I1(N, CODE)
+   !< ENCODE SCALAR NUMBER TO BASE64 (I1P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=120_I1P, CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> EA== <<<
+   INTEGER(I1P),                  INTENT(IN)  :: N       !< NUMBER TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+
+   ALLOCATE(NI1P(1:((BYI1P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYI1P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((BYI1P),3_I1P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I1
+
+   PURE SUBROUTINE B64_ENCODE_STRING(S, CODE)
+   !< ENCODE SCALAR STRING TO BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(S='HELLO', CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AGVSBG8= <<<
+   CHARACTER(*),                  INTENT(IN)  :: S       !< STRING TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I4P)                               :: BYCHS   !< BYTES OF CHARACTER STRING.
+
+   BYCHS = BYTE_SIZE(S)
+   ALLOCATE(NI1P(1:((BYCHS+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYCHS+2)/3)*4)
+   NI1P = TRANSFER(S,NI1P)
+   PADD = MOD((BYCHS),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_STRING
+
+   PURE SUBROUTINE B64_ENCODE_R16_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (R16P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[121._R16P,2.32_R16P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAABAXKCPWVUOXI8CQA== <<<
+   REAL(R16P),                    INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYR16P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYR16P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYR16P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R16_A
+
+   PURE SUBROUTINE B64_ENCODE_R8_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (R8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[1._R8P,2._R8P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAAAA8D8AAAAAAAAAQA== <<<
+   REAL(R8P),                     INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYR8P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYR8P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYR8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R8_A
+
+   PURE SUBROUTINE B64_ENCODE_R4_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (R4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[0._R4P,-32.12_R4P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AAAAAOF6AMI= <<<
+   REAL(R4P),                     INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYR4P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYR4P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYR4P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_R4_A
+
+   PURE SUBROUTINE B64_ENCODE_I8_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (I8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[23_I8P,324_I8P,25456656_I8P,2_I8P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA= <<<
+   INTEGER(I8P),                  INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYI8P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYI8P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYI8P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I8_A
+
+   PURE SUBROUTINE B64_ENCODE_I4_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (I4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[2023_I4P,-24_I4P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> 5WCAAOJ///8= <<<
+   INTEGER(I4P),                  INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYI4P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYI4P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYI4P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I4_A
+
+   PURE SUBROUTINE B64_ENCODE_I2_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (I2P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[-203_I2P,-10_I2P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> NF/2/W== <<<
+   INTEGER(I2P),                  INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYI2P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYI2P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYI2P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I2_A
+
+   PURE SUBROUTINE B64_ENCODE_I1_A(N, CODE)
+   !< ENCODE ARRAY NUMBERS TO BASE64 (I1P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(N=[120_I1P,-1_I1P], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> EP8= <<<
+   INTEGER(I1P),                  INTENT(IN)  :: N(1:)   !< ARRAY OF NUMBERS TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I8P)                               :: NS      !< SIZE OF N.
+
+   NS = SIZE(N,DIM=1)
+   ALLOCATE(NI1P(1:((NS*BYI1P+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((NS*BYI1P+2)/3)*4)
+   NI1P = TRANSFER(N,NI1P)
+   PADD = MOD((NS*BYI1P),3_I8P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_I1_A
+
+   PURE SUBROUTINE B64_ENCODE_STRING_A(S, CODE)
+   !< ENCODE ARRAY STRING TO BASE64.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(LEN=:), ALLOCATABLE :: CODE64
+   !< CALL B64_ENCODE(S=['HELLO','WORLD'], CODE=CODE64)
+   !< PRINT "(A)", CODE64
+   !<```
+   !=> AGVSBG93B3JSZA== <<<
+   CHARACTER(*),                  INTENT(IN)  :: S(1:)   !< STRING TO BE ENCODED.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P),     ALLOCATABLE              :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+   INTEGER(I4P)                               :: PADD    !< NUMBER OF PADDING CHARACTERS ('=').
+   INTEGER(I4P)                               :: BYCHS   !< BYTES OF CHARACTER STRING.
+
+   BYCHS = BYTE_SIZE(S(1))*SIZE(S,DIM=1)
+   ALLOCATE(NI1P(1:((BYCHS+2)/3)*3)) ; NI1P = 0_I1P
+   CODE = REPEAT(' ',((BYCHS+2)/3)*4)
+   NI1P = TRANSFER(S,NI1P)
+   PADD = MOD((BYCHS),3_I4P) ; IF (PADD>0_I4P) PADD = 3_I4P - PADD
+   CALL ENCODE_BITS(BITS=NI1P,PADD=PADD,CODE=CODE)
+   ENDSUBROUTINE B64_ENCODE_STRING_A
+
+   ELEMENTAL SUBROUTINE B64_DECODE_R16(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R16P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R16P) :: SCALAR_R16
+   !< CALL B64_DECODE(CODE='CKWCWMTHYEA=',N=SCALAR_R16)
+   !< PRINT "(L1)", SCALAR_R16==134.231_R16P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   REAL(R16P),   INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYR16P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R16
+
+   ELEMENTAL SUBROUTINE B64_DECODE_R8(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P) :: SCALAR_R8
+   !< CALL B64_DECODE(CODE='AAAAAAAA8D8=',N=SCALAR_R8)
+   !< PRINT "(L1)", SCALAR_R8==1._R8P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   REAL(R8P),    INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYR8P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R8
+
+   ELEMENTAL SUBROUTINE B64_DECODE_R4(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (R4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P) :: SCALAR_R4
+   !< CALL B64_DECODE(CODE='AAAAAA==',N=SCALAR_R4)
+   !< PRINT "(L1)", SCALAR_R4==0._R4P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   REAL(R4P),    INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYR4P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R4
+
+   ELEMENTAL SUBROUTINE B64_DECODE_I8(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P) :: SCALAR_I8
+   !< CALL B64_DECODE(CODE='FWAAAAAAAAA=',N=SCALAR_I8)
+   !< PRINT "(L1)", SCALAR_I8==23_I8P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   INTEGER(I8P), INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYI8P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I8
+
+   ELEMENTAL SUBROUTINE B64_DECODE_I4(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P) :: SCALAR_I4
+   !< CALL B64_DECODE(CODE='5WCAAA==',N=SCALAR_I4)
+   !< PRINT "(L1)", SCALAR_I4==2023_I4P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   INTEGER(I4P), INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYI4P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I4
+
+   ELEMENTAL SUBROUTINE B64_DECODE_I2(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I2P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P) :: SCALAR_I2
+   !< CALL B64_DECODE(CODE='NF8=',N=SCALAR_I2)
+   !< PRINT "(L1)", SCALAR_I2==-203_I2P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   INTEGER(I2P), INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYI2P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I2
+
+   ELEMENTAL SUBROUTINE B64_DECODE_I1(CODE, N)
+   !< DECODE A BASE64 CODE INTO A SCALAR NUMBER (I1P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P) :: SCALAR_I1
+   !< CALL B64_DECODE(CODE='EA==',N=SCALAR_I1)
+   !< PRINT "(L1)", SCALAR_I1==120_I1P
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   INTEGER(I1P), INTENT(OUT) :: N       !< NUMBER TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYI1P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I1
+
+   ELEMENTAL SUBROUTINE B64_DECODE_STRING(CODE, S)
+   !< DECODE A BASE64 CODE INTO A SCALAR STRING.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(:), ALLOCATABLE :: CODE64
+   !< CODE64 = REPEAT(' ',5)
+   !< CALL B64_DECODE(CODE='AGVSBG8=',S=CODE64)
+   !< PRINT "(L1)", CODE64=='HELLO'
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   CHARACTER(*), INTENT(OUT) :: S       !< STRING TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYTE_SIZE(S))) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   S = TRANSFER(NI1P,S)
+   ENDSUBROUTINE B64_DECODE_STRING
+
+   PURE SUBROUTINE B64_DECODE_R16_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R16P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R16P) :: ARRAY_R16(1:2)
+   !< CALL B64_DECODE(CODE='AAAAAABAXKCPWVUOXI8CQA==',N=ARRAY_R16)
+   !< PRINT "(L1)", STR(N=ARRAY_R16)==STR(N=[121._R16P,2.32_R16P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   REAL(R16P),   INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR16P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R16_A
+
+   PURE SUBROUTINE B64_DECODE_R8_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R8P) :: ARRAY_R8(1:2)
+   !< CALL B64_DECODE(CODE='AAAAAAAA8D8AAAAAAAAAQA==',N=ARRAY_R8)
+   !< PRINT "(L1)", STR(N=ARRAY_R8)==STR(N=[1._R8P,2._R8P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   REAL(R8P),    INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR8P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R8_A
+
+   PURE SUBROUTINE B64_DECODE_R4_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (R4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< REAL(R4P) :: ARRAY_R4(1:2)
+   !< CALL B64_DECODE(CODE='AAAAAOF6AMI=',N=ARRAY_R4)
+   !< PRINT "(L1)", STR(N=ARRAY_R4)==STR(N=[0._R4P,-32.12_R4P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   REAL(R4P),    INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYR4P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_R4_A
+
+   PURE SUBROUTINE B64_DECODE_I8_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I8P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I8P) :: ARRAY_I8(1:4)
+   !< CALL B64_DECODE(CODE='FWAAAAAAAABEAQAAAAAAABBWHAEAAAAAAGAAAAAAAAA=',N=ARRAY_I8)
+   !< PRINT "(L1)", STR(N=ARRAY_I8)==STR(N=[23_I8P,324_I8P,25456656_I8P,2_I8P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   INTEGER(I8P), INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI8P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I8_A
+
+   PURE SUBROUTINE B64_DECODE_I4_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I4P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I4P) :: ARRAY_I4(1:2)
+   !< CALL B64_DECODE(CODE='5WCAAOJ///8=',N=ARRAY_I4)
+   !< PRINT "(L1)", STR(N=ARRAY_I4)==STR(N=[2023_I4P,-24_I4P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   INTEGER(I4P), INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI4P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I4_A
+
+   PURE SUBROUTINE B64_DECODE_I2_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I2P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I2P) :: ARRAY_I2(1:2)
+   !< CALL B64_DECODE(CODE='NF/2/W==',N=ARRAY_I2)
+   !< PRINT "(L1)", STR(N=ARRAY_I2)==STR(N=[-203_I2P,-10_I2P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   INTEGER(I2P), INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI2P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I2_A
+
+   PURE SUBROUTINE B64_DECODE_I1_A(CODE, N)
+   !< DECODE A BASE64 CODE INTO AN ARRAY NUMBERS (I1P).
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< INTEGER(I1P) :: ARRAY_I1(1:2)
+   !< CALL B64_DECODE(CODE='EP8=',N=ARRAY_I1)
+   !< PRINT "(L1)", STR(N=ARRAY_I1)==STR(N=[120_I1P,-1_I1P])
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED ARRAY.
+   INTEGER(I1P), INTENT(OUT) :: N(1:)   !< ARRAY OF NUMBERS TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:SIZE(N,DIM=1)*BYI1P)) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   N = TRANSFER(NI1P,N)
+   ENDSUBROUTINE B64_DECODE_I1_A
+
+   PURE SUBROUTINE B64_DECODE_STRING_A(CODE, S)
+   !< DECODE A BASE64 CODE INTO AN ARRAY OF STRINGS.
+   !<
+   !<```FORTRAN
+   !< USE BEFOR64
+   !< USE PENF
+   !< CHARACTER(5) :: ARRAY_S(1:2)
+   !< CALL B64_DECODE(CODE='AGVSBG93B3JSZA==',S=ARRAY_S)
+   !< PRINT "(L1)", ARRAY_S(1)//ARRAY_S(2)=='HELLOWORLD'
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN)  :: CODE    !< ENCODED SCALAR.
+   CHARACTER(*), INTENT(OUT) :: S(1:)   !< STRING TO BE DECODED.
+   INTEGER(I1P), ALLOCATABLE :: NI1P(:) !< ONE BYTE INTEGER ARRAY CONTAINING N.
+
+   ALLOCATE(NI1P(1:BYTE_SIZE(S(1))*SIZE(S,DIM=1))) ; NI1P = 0_I1P
+   CALL DECODE_BITS(CODE=CODE,BITS=NI1P)
+   S = TRANSFER(NI1P,S)
+   ENDSUBROUTINE B64_DECODE_STRING_A
+ENDMODULE BEFOR64
+
+
+
+
+
+
+
+!< FACE, FORTRAN ANSI COLORS ENVIRONMENT.
+MODULE FACE
+!< FACE, FORTRAN ANSI COLORS ENVIRONMENT.
+USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: INT32
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: COLORIZE
+PUBLIC :: COLORS_SAMPLES
+PUBLIC :: STYLES_SAMPLES
+PUBLIC :: ASCII
+PUBLIC :: UCS4
+
+INTERFACE COLORIZE
+#if defined ASCII_SUPPORTED && defined ASCII_NEQ_DEFAULT
+   MODULE PROCEDURE COLORIZE_ASCII
+   MODULE PROCEDURE COLORIZE_DEFAULT
+#else
+   MODULE PROCEDURE COLORIZE_DEFAULT
+#endif
+#ifdef UCS4_SUPPORTED
+   MODULE PROCEDURE COLORIZE_UCS4
+#endif
+ENDINTERFACE
+
+! KIND PARAMETERS
+#ifdef ASCII_SUPPORTED
+INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII')     !< ASCII CHARACTER SET KIND.
+#else
+INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT')   !< ASCII CHARACTER SET KIND.
+#endif
+#ifdef UCS4_SUPPORTED
+INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND.
+#else
+INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('DEFAULT')   !< UNICODE CHARACTER SET KIND.
+#endif
+! PARAMETERS
+CHARACTER(26), PARAMETER :: UPPER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET.
+CHARACTER(26), PARAMETER :: LOWER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET.
+CHARACTER(1),  PARAMETER :: NL=NEW_LINE('A')                            !< NEW LINE CHARACTER.
+CHARACTER(1),  PARAMETER :: ESCAPE=ACHAR(27)                            !< "\" CHARACTER.
+! CODES
+CHARACTER(2), PARAMETER :: CODE_START=ESCAPE//'['               !< START ANSI CODE, "\[".
+CHARACTER(1), PARAMETER :: CODE_END='M'                         !< END ANSI CODE, "M".
+CHARACTER(4), PARAMETER :: CODE_CLEAR=CODE_START//'0'//CODE_END !< CLEAR ALL STYLES, "\[0M".
+! STYLES CODES
+CHARACTER(17), PARAMETER :: STYLES(1:2,1:16)=RESHAPE([&
+             'BOLD_ON          ','1                ', &         !  BOLD ON.
+             'ITALICS_ON       ','3                ', &         !  ITALICS ON.
+             'UNDERLINE_ON     ','4                ', &         !  UNDERLINE ON.
+             'INVERSE_ON       ','7                ', &         !  INVERSE ON: REVERSE FOREGROUND AND BACKGROUND COLORS.
+             'STRIKETHROUGH_ON ','9                ', &         !  STRIKETHROUGH ON.
+             'BOLD_OFF         ','22               ', &         !  BOLD OFF.
+             'ITALICS_OFF      ','23               ', &         !  ITALICS OFF.
+             'UNDERLINE_OFF    ','24               ', &         !  UNDERLINE OFF.
+             'INVERSE_OFF      ','27               ', &         !  INVERSE OFF: REVERSE FOREGROUND AND BACKGROUND COLORS.
+             'STRIKETHROUGH_OFF','29               ', &         !  STRIKETHROUGH OFF.
+             'FRAMED_ON        ','51               ', &         !  FRAMED ON.
+             'ENCIRCLED_ON     ','52               ', &         !  ENCIRCLED ON.
+             'OVERLINED_ON     ','53               ', &         !  OVERLINED ON.
+             'FRAMED_OFF       ','54               ', &         !  FRAMED OFF.
+             'ENCIRCLED_OFF    ','54               ', &         !  ENCIRCLED OFF.
+             'OVERLINED_OFF    ','55               '  &         !  OVERLINED OFF.
+                                                     ], [2,16]) !< STYLES.
+! COLORS CODES
+CHARACTER(15), PARAMETER :: COLORS_FG(1:2,1:17)=RESHAPE([&
+                    'BLACK          ','30             ', &         !  BLACK.
+                    'RED            ','31             ', &         !  RED.
+                    'GREEN          ','32             ', &         !  GREEN.
+                    'YELLOW         ','33             ', &         !  YELLOW.
+                    'BLUE           ','34             ', &         !  BLUE.
+                    'MAGENTA        ','35             ', &         !  MAGENTA.
+                    'CYAN           ','36             ', &         !  CYAN.
+                    'WHITE          ','37             ', &         !  WHITE.
+                    'DEFAULT        ','39             ', &         !  DEFAULT (WHITE).
+                    'BLACK_INTENSE  ','90             ', &         !  BLACK INTENSE.
+                    'RED_INTENSE    ','91             ', &         !  RED INTENSE.
+                    'GREEN_INTENSE  ','92             ', &         !  GREEN INTENSE.
+                    'YELLOW_INTENSE ','93             ', &         !  YELLOW INTENSE.
+                    'BLUE_INTENSE   ','94             ', &         !  BLUE INTENSE.
+                    'MAGENTA_INTENSE','95             ', &         !  MAGENTA INTENSE.
+                    'CYAN_INTENSE   ','96             ', &         !  CYAN INTENSE.
+                    'WHITE_INTENSE  ','97             '  &         !  WHITE INTENSE.
+                                                        ], [2,17]) !< FOREGROUND COLORS.
+CHARACTER(15), PARAMETER :: COLORS_BG(1:2,1:17)=RESHAPE([&
+                    'BLACK          ','40             ', &         !  BLACK.
+                    'RED            ','41             ', &         !  RED.
+                    'GREEN          ','42             ', &         !  GREEN.
+                    'YELLOW         ','43             ', &         !  YELLOW.
+                    'BLUE           ','44             ', &         !  BLUE.
+                    'MAGENTA        ','45             ', &         !  MAGENTA.
+                    'CYAN           ','46             ', &         !  CYAN.
+                    'WHITE          ','47             ', &         !  WHITE.
+                    'DEFAULT        ','49             ', &         !  DEFAULT (BLACK).
+                    'BLACK_INTENSE  ','100            ', &         !  BLACK INTENSE.
+                    'RED_INTENSE    ','101            ', &         !  RED INTENSE.
+                    'GREEN_INTENSE  ','102            ', &         !  GREEN INTENSE.
+                    'YELLOW_INTENSE ','103            ', &         !  YELLOW INTENSE.
+                    'BLUE_INTENSE   ','104            ', &         !  BLUE INTENSE.
+                    'MAGENTA_INTENSE','105            ', &         !  MAGENTA INTENSE.
+                    'CYAN_INTENSE   ','106            ', &         !  CYAN INTENSE.
+                    'WHITE_INTENSE  ','107            '  &         !  WHITE INTENSE.
+                                                        ], [2,17]) !< BACKGROUND COLORS.
+CONTAINS
+   ! PUBLIC PROCEDURES
+   SUBROUTINE COLORS_SAMPLES()
+   !< PRINT TO STANDARD OUTPUT ALL COLORS SAMPLES.
+   INTEGER(INT32) :: C !< COUNTER.
+
+   PRINT '(A)', COLORIZE('FOREGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE')
+   DO C=1, SIZE(COLORS_FG, DIM=2)
+      PRINT '(A)', '  COLORIZE("'//COLORS_FG(1, C)//'", COLOR_FG="'//COLORS_FG(1, C)//'") => '//&
+         COLORIZE(COLORS_FG(1, C), COLOR_FG=COLORS_FG(1, C))//&
+         ' CODE: '//COLORIZE(TRIM(COLORS_FG(2, C)), COLOR_FG=COLORS_FG(1, C), STYLE='INVERSE_ON')
+   ENDDO
+   PRINT '(A)', COLORIZE('BACKGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE')
+   DO C=1, SIZE(COLORS_BG, DIM=2)
+      PRINT '(A)', '  COLORIZE("'//COLORS_BG(1, C)//'", COLOR_BG="'//COLORS_BG(1, C)//'") => '//&
+         COLORIZE(COLORS_BG(1, C), COLOR_BG=COLORS_BG(1, C))//&
+         ' CODE: '//COLORIZE(TRIM(COLORS_BG(2, C)), COLOR_BG=COLORS_BG(1, C), STYLE='INVERSE_ON')
+   ENDDO
+   ENDSUBROUTINE COLORS_SAMPLES
+
+   SUBROUTINE STYLES_SAMPLES()
+   !< PRINT TO STANDARD OUTPUT ALL STYLES SAMPLES.
+   INTEGER(INT32) :: S !< COUNTER.
+
+   PRINT '(A)', COLORIZE('STYLES SAMPLES', COLOR_FG='RED_INTENSE')
+   DO S=1, SIZE(STYLES, DIM=2)
+      PRINT '(A)', '  COLORIZE("'//STYLES(1, S)//'", STYLE="'//STYLES(1, S)//'") => '//&
+         COLORIZE(STYLES(1, S), STYLE=STYLES(1, S))//&
+         ' CODE: '//COLORIZE(TRIM(STYLES(2, S)), COLOR_FG='MAGENTA', STYLE='INVERSE_ON')
+   ENDDO
+   ENDSUBROUTINE STYLES_SAMPLES
+
+   ! PRIVATE PROCEDURES
+   PURE FUNCTION COLORIZE_ASCII(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
+   !< COLORIZE AND STYLIZE STRINGS, ASCII KIND.
+   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN)           :: STRING    !< INPUT STRING.
+   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
+   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
+   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE          :: BUFFER    !< TEMPORARY BUFFER.
+   INTEGER(INT32)                                     :: I         !< COUNTER.
+
+   COLORIZED = STRING
+   IF (PRESENT(COLOR_FG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_FG))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   IF (PRESENT(COLOR_BG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_BG))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   IF (PRESENT(STYLE)) THEN
+      I = STYLE_INDEX(UPPER(STYLE))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   ENDFUNCTION COLORIZE_ASCII
+
+   PURE FUNCTION COLORIZE_DEFAULT(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
+   !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND.
+   CHARACTER(LEN=*), INTENT(IN)           :: STRING    !< INPUT STRING.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
+   CHARACTER(LEN=:), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
+   INTEGER(INT32)                         :: I         !< COUNTER.
+
+   COLORIZED = STRING
+   IF (PRESENT(COLOR_FG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_FG))
+      IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END//COLORIZED//CODE_CLEAR
+   ENDIF
+   IF (PRESENT(COLOR_BG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_BG))
+      IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END//COLORIZED//CODE_CLEAR
+   ENDIF
+   IF (PRESENT(STYLE)) THEN
+      I = STYLE_INDEX(UPPER(STYLE))
+      IF (I>0) COLORIZED = CODE_START//TRIM(STYLES(2, I))//CODE_END//COLORIZED//CODE_CLEAR
+   ENDIF
+   ENDFUNCTION COLORIZE_DEFAULT
+
+   PURE FUNCTION COLORIZE_UCS4(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
+   !< COLORIZE AND STYLIZE STRINGS, UCS4 KIND.
+   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)           :: STRING    !< INPUT STRING.
+   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
+   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
+   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE          :: BUFFER    !< TEMPORARY BUFFER.
+   INTEGER(INT32)                                    :: I         !< COUNTER.
+
+   COLORIZED = STRING
+   IF (PRESENT(COLOR_FG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_FG))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   IF (PRESENT(COLOR_BG)) THEN
+      I = COLOR_INDEX(UPPER(COLOR_BG))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   IF (PRESENT(STYLE)) THEN
+      I = STYLE_INDEX(UPPER(STYLE))
+      IF (I>0) THEN
+         BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END
+         COLORIZED = BUFFER//COLORIZED
+         BUFFER = CODE_CLEAR
+         COLORIZED = COLORIZED//BUFFER
+      ENDIF
+   ENDIF
+   ENDFUNCTION COLORIZE_UCS4
+
+   ELEMENTAL FUNCTION COLOR_INDEX(COLOR)
+   !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED COLOR.
+   !<
+   !< @NOTE BECAUSE FOREGROUND AND BACKROUND COLORS LISTS SHARE THE SAME NAME, NO MATTER WHAT ARRAY IS USED TO FIND THE COLOR INDEX.
+   !< THUS, THE FOREGROUND ARRAY IS USED.
+   CHARACTER(LEN=*), INTENT(IN) :: COLOR       !< COLOR DEFINITION.
+   INTEGER(INT32)               :: COLOR_INDEX !< INDEX INTO THE COLORS ARRAYS.
+   INTEGER(INT32)               :: C           !< COUNTER.
+
+   COLOR_INDEX = 0
+   DO C=1, SIZE(COLORS_FG, DIM=2)
+      IF (TRIM(COLORS_FG(1, C))==TRIM(ADJUSTL(COLOR))) THEN
+         COLOR_INDEX = C
+         EXIT
+      ENDIF
+   ENDDO
+   ENDFUNCTION COLOR_INDEX
+
+   ELEMENTAL FUNCTION STYLE_INDEX(STYLE)
+   !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED STYLE.
+   CHARACTER(LEN=*), INTENT(IN) :: STYLE       !< STYLE DEFINITION.
+   INTEGER(INT32)               :: STYLE_INDEX !< INDEX INTO THE STYLES ARRAY.
+   INTEGER(INT32)               :: S           !< COUNTER.
+
+   STYLE_INDEX = 0
+   DO S=1, SIZE(STYLES, DIM=2)
+      IF (TRIM(STYLES(1, S))==TRIM(ADJUSTL(STYLE))) THEN
+         STYLE_INDEX = S
+         EXIT
+      ENDIF
+   ENDDO
+   ENDFUNCTION STYLE_INDEX
+
+   ELEMENTAL FUNCTION UPPER(STRING)
+   !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS.
+   CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING.
+   CHARACTER(LEN=LEN(STRING))   :: UPPER  !< UPPER CASE STRING.
+   INTEGER                      :: N1     !< CHARACTERS COUNTER.
+   INTEGER                      :: N2     !< CHARACTERS COUNTER.
+
+   UPPER = STRING
+   DO N1=1, LEN(STRING)
+      N2 = INDEX(LOWER_ALPHABET, STRING(N1:N1))
+      IF (N2>0) UPPER(N1:N1) = UPPER_ALPHABET(N2:N2)
+   ENDDO
+   ENDFUNCTION UPPER
+ENDMODULE FACE
+
+
+
+
+
+!< STRINGIFOR, DEFINITION OF `STRING` TYPE.
+MODULE STRINGIFOR_STRING_T
+!< STRINGIFOR, DEFINITION OF `STRING` TYPE.
+USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_EOR
+USE BEFOR64, ONLY : B64_DECODE, B64_ENCODE
+USE FACE, ONLY : COLORIZE
+USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P, STR
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+! EXPOSE STINGIFOR OVERLOADED BUILTINS AND OPERATORS
+! PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY
+PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY
+! EXPOSE STINGIFOR OBJECTS
+PUBLIC :: CK
+PUBLIC :: GLOB
+PUBLIC :: STRJOIN
+PUBLIC :: STRING
+
+INTEGER, PARAMETER :: CK = SELECTED_CHAR_KIND('DEFAULT') !< DEFAULT CHARACTER KIND.
+
+TYPE :: STRING
+  !< OOP DESIGNED STRING CLASS.
+  CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW !< RAW DATA.
+  CONTAINS
+    ! PUBLIC METHODS
+    ! BUILTINS REPLACEMENTS
+    PROCEDURE, PASS(SELF) :: ADJUSTL  => SADJUSTL                 !< ADJUSTL REPLACEMENT.
+    PROCEDURE, PASS(SELF) :: ADJUSTR  => SADJUSTR                 !< ADJUSTR REPLACEMENT.
+    PROCEDURE, PASS(SELF) :: COUNT    => SCOUNT                   !< COUNT REPLACEMENT.
+    GENERIC               :: INDEX    => SINDEX_STRING_STRING, &
+                                         SINDEX_STRING_CHARACTER  !< INDEX REPLACEMENT.
+    PROCEDURE, PASS(SELF) :: LEN      => SLEN                     !< LEN REPLACEMENT.
+    PROCEDURE, PASS(SELF) :: LEN_TRIM => SLEN_TRIM                !< LEN_TRIM REPLACEMENT.
+    GENERIC               :: REPEAT   => SREPEAT_STRING_STRING, &
+                                         SREPEAT_CHARACTER_STRING !< REPEAT REPLACEMENT.
+    GENERIC               :: SCAN     => SSCAN_STRING_STRING,    &
+                                         SSCAN_STRING_CHARACTER   !< SCAN REPLACEMENT.
+    PROCEDURE, PASS(SELF) :: TRIM     => STRIM                    !< TRIM REPLACEMENT.
+    GENERIC               :: VERIFY   => SVERIFY_STRING_STRING, &
+                                         SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT.
+    ! AUXILIARY METHODS
+    PROCEDURE, PASS(SELF) :: BASEDIR          !< RETURN THE BASE DIRECTORY NAME OF A STRING CONTAINING A FILE NAME.
+    PROCEDURE, PASS(SELF) :: BASENAME         !< RETURN THE BASE FILE NAME OF A STRING CONTAINING A FILE NAME.
+    PROCEDURE, PASS(SELF) :: CAMELCASE        !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES.
+    PROCEDURE, PASS(SELF) :: CAPITALIZE       !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED.
+    PROCEDURE, PASS(SELF) :: CHARS            !< RETURN THE RAW CHARACTERS DATA.
+    GENERIC               :: COLORIZE => &
+                             COLORIZE_STR     !< COLORIZE AND STYLIZE STRINGS.
+    PROCEDURE, PASS(SELF) :: DECODE           !< DECODE STRING.
+    PROCEDURE, PASS(SELF) :: ENCODE           !< ENCODE STRING.
+    PROCEDURE, PASS(SELF) :: ESCAPE           !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER).
+    PROCEDURE, PASS(SELF) :: EXTENSION        !< RETURN THE EXTENSION OF A STRING CONTAINING A FILE NAME.
+    PROCEDURE, PASS(SELF) :: FILL             !< PAD STRING ON THE LEFT (OR RIGHT) WITH ZEROS (OR OTHER CHAR) TO FILL WIDTH.
+    PROCEDURE, PASS(SELF) :: FREE             !< FREE DYNAMIC MEMORY.
+    GENERIC               :: GLOB =>         &
+                             GLOB_CHARACTER, &
+                             GLOB_STRING      !< GLOB SEARCH, FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN.
+    GENERIC               :: INSERT =>      &
+                             INSERT_STRING, &
+                             INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
+    GENERIC               :: JOIN =>       &
+                             JOIN_STRINGS, &
+                             JOIN_CHARACTERS  !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS OR CHARACTERS.
+    GENERIC               :: STRJOIN =>   &
+                             STRJOIN_STRINGS, &
+                             STRJOIN_CHARACTERS, &
+                             STRJOIN_STRINGS_ARRAY, &
+                             STRJOIN_CHARACTERS_ARRAY  !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS OR CHARACTERS;
+                                                       !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS OR CHARACTERS IN COLUMNS OR ROWS.
+    PROCEDURE, PASS(SELF) :: LOWER            !< RETURN A STRING WITH ALL LOWERCASE CHARACTERS.
+    PROCEDURE, PASS(SELF) :: PARTITION        !< SPLIT STRING AT SEPARATOR AND RETURN THE 3 PARTS (BEFORE, THE SEPARATOR AND AFTER).
+    PROCEDURE, PASS(SELF) :: READ_FILE        !< READ A FILE A SINGLE STRING STREAM.
+    PROCEDURE, PASS(SELF) :: READ_LINE        !< READ LINE (RECORD) FROM A CONNECTED UNIT.
+    PROCEDURE, PASS(SELF) :: READ_LINES       !< READ (ALL) LINES (RECORDS) FROM A CONNECTED UNIT AS A SINGLE ASCII STREAM.
+    PROCEDURE, PASS(SELF) :: REPLACE          !< RETURN A STRING WITH ALL OCCURRENCES OF SUBSTRING OLD REPLACED BY NEW.
+    PROCEDURE, PASS(SELF) :: REVERSE          !< RETURN A REVERSED STRING.
+    PROCEDURE, PASS(SELF) :: SEARCH           !< SEARCH FOR *TAGGED* RECORD INTO STRING.
+    PROCEDURE, PASS(SELF) :: SLICE            !< RETURN THE RAW CHARACTERS DATA SLICED.
+    PROCEDURE, PASS(SELF) :: SNAKECASE        !< RETURN A STRING WITH ALL WORDS LOWERCASE SEPARATED BY "_".
+    PROCEDURE, PASS(SELF) :: SPLIT            !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING.
+    PROCEDURE, PASS(SELF) :: SPLIT_CHUNKED    !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING.
+    PROCEDURE, PASS(SELF) :: STARTCASE        !< RETURN A STRING WITH ALL WORDS CAPITALIZED, E.G. TITLE CASE.
+    PROCEDURE, PASS(SELF) :: STRIP            !< RETURN A STRING WITH THE LEADING AND TRAILING CHARACTERS REMOVED.
+    PROCEDURE, PASS(SELF) :: SWAPCASE         !< RETURN A STRING WITH UPPERCASE CHARS CONVERTED TO LOWERCASE AND VICE VERSA.
+    PROCEDURE, PASS(SELF) :: TEMPNAME         !< RETURN A SAFE TEMPORARY NAME SUITABLE FOR TEMPORARY FILE OR DIRECTORIES.
+    GENERIC               :: TO_NUMBER =>   &
+                             TO_INTEGER_I1P,&
+#ifndef _NVF
+                             TO_INTEGER_I2P,&
+#endif
+                             TO_INTEGER_I4P,&
+                             TO_INTEGER_I8P,&
+#if defined _R16P
+                             TO_REAL_R16P,  &
+#endif
+                             TO_REAL_R8P,   &
+                             TO_REAL_R4P      !< CAST STRING TO NUMBER.
+    PROCEDURE, PASS(SELF) :: UNESCAPE         !< UNESCAPE DOUBLE BACKSLASHES (OR CUSTOM ESCAPED CHARACTER).
+    PROCEDURE, PASS(SELF) :: UNIQUE           !< REDUCE TO ONE (UNIQUE) MULTIPLE OCCURRENCES OF A SUBSTRING INTO A STRING.
+    PROCEDURE, PASS(SELF) :: UPPER            !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS.
+    PROCEDURE, PASS(SELF) :: WRITE_FILE       !< WRITE A SINGLE STRING STREAM INTO FILE.
+    PROCEDURE, PASS(SELF) :: WRITE_LINE       !< WRITE LINE (RECORD) TO A CONNECTED UNIT.
+    PROCEDURE, PASS(SELF) :: WRITE_LINES      !< WRITE LINES (RECORDS) TO A CONNECTED UNIT.
+    ! INQUIRE METHODS
+    PROCEDURE, PASS(SELF) :: END_WITH     !< RETURN TRUE IF A STRING ENDS WITH A SPECIFIED SUFFIX.
+    PROCEDURE, PASS(SELF) :: IS_ALLOCATED !< RETURN TRUE IF THE STRING IS ALLOCATED.
+    PROCEDURE, PASS(SELF) :: IS_DIGIT     !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE DIGITS.
+    PROCEDURE, PASS(SELF) :: IS_INTEGER   !< RETURN TRUE IF THE STRING CONTAINS AN INTEGER.
+    PROCEDURE, PASS(SELF) :: IS_LOWER     !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE LOWERCASE.
+    PROCEDURE, PASS(SELF) :: IS_NUMBER    !< RETURN TRUE IF THE STRING CONTAINS A NUMBER (REAL OR INTEGER).
+    PROCEDURE, PASS(SELF) :: IS_REAL      !< RETURN TRUE IF THE STRING CONTAINS AN REAL.
+    PROCEDURE, PASS(SELF) :: IS_UPPER     !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE UPPERCASE.
+    PROCEDURE, PASS(SELF) :: START_WITH   !< RETURN TRUE IF A STRING STARTS WITH A SPECIFIED PREFIX.
+    ! OPERATORS
+    GENERIC :: ASSIGNMENT(=) => STRING_ASSIGN_STRING,      &
+                                STRING_ASSIGN_CHARACTER,   &
+                                STRING_ASSIGN_INTEGER_I1P, &
+                                STRING_ASSIGN_INTEGER_I2P, &
+                                STRING_ASSIGN_INTEGER_I4P, &
+                                STRING_ASSIGN_INTEGER_I8P, &
+#if defined _R16P
+                                STRING_ASSIGN_REAL_R16P,   &
+#endif
+                                STRING_ASSIGN_REAL_R8P,    &
+                                STRING_ASSIGN_REAL_R4P              !< ASSIGNMENT OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(//) => STRING_CONCAT_STRING,    &
+                               STRING_CONCAT_CHARACTER, &
+                               CHARACTER_CONCAT_STRING              !< CONCATENATION OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(.CAT.) => STRING_CONCAT_STRING_STRING,    &
+                                  STRING_CONCAT_CHARACTER_STRING, &
+                                  CHARACTER_CONCAT_STRING_STRING    !< CONCATENATION OPERATOR (STRING OUTPUT) OVERLOADING.
+    GENERIC :: OPERATOR(==) => STRING_EQ_STRING,    &
+                               STRING_EQ_CHARACTER, &
+                               CHARACTER_EQ_STRING                  !< EQUAL OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(/=) => STRING_NE_STRING,    &
+                               STRING_NE_CHARACTER, &
+                               CHARACTER_NE_STRING                  !< NOT EQUAL OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(<) => STRING_LT_STRING,    &
+                              STRING_LT_CHARACTER, &
+                              CHARACTER_LT_STRING                   !< LOWER THAN OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(<=) => STRING_LE_STRING,    &
+                               STRING_LE_CHARACTER, &
+                               CHARACTER_LE_STRING                  !< LOWER EQUAL THAN OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(>=) => STRING_GE_STRING,    &
+                               STRING_GE_CHARACTER, &
+                               CHARACTER_GE_STRING                  !< GREATER EQUAL THAN OPERATOR OVERLOADING.
+    GENERIC :: OPERATOR(>) => STRING_GT_STRING,    &
+                              STRING_GT_CHARACTER, &
+                              CHARACTER_GT_STRING                   !< GREATER THAN OPERATOR OVERLOADING.
+    ! IO
+    GENERIC :: READ(FORMATTED) => READ_FORMATTED       !< FORMATTED INPUT.
+    GENERIC :: WRITE(FORMATTED) => WRITE_FORMATTED     !< FORMATTED OUTPUT.
+    GENERIC :: READ(UNFORMATTED) => READ_UNFORMATTED   !< UNFORMATTED INPUT.
+    GENERIC :: WRITE(UNFORMATTED) => WRITE_UNFORMATTED !< UNFORMATTED OUTPUT.
+    ! PRIVATE METHODS
+    ! BUILTINS REPLACEMENTS
+    PROCEDURE, PRIVATE, PASS(SELF) :: SINDEX_STRING_STRING     !< INDEX REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SINDEX_STRING_CHARACTER  !< INDEX REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SREPEAT_STRING_STRING    !< REPEAT REPLACEMENT.
+    PROCEDURE, PRIVATE, NOPASS     :: SREPEAT_CHARACTER_STRING !< REPEAT REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SSCAN_STRING_STRING      !< SCAN REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SSCAN_STRING_CHARACTER   !< SCAN REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_STRING    !< VERIFY REPLACEMENT.
+    PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT.
+    ! AUXILIARY METHODS
+    PROCEDURE, PRIVATE, PASS(SELF) :: COLORIZE_STR     !< COLORIZE AND STYLIZE STRINGS.
+    PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_CHARACTER   !< GLOB SEARCH (CHARACTER OUTPUT).
+    PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_STRING      !< GLOB SEARCH (STRING OUTPUT).
+    PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_STRING    !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
+    PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
+    PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_STRINGS     !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
+    PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_CHARACTERS  !< RETURN JOIN STRING OF AN ARRAY OF CHARACTERS.
+    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_STRINGS  !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
+    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_CHARACTERS        !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
+    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_STRINGS_ARRAY     !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN COLUMNS OR ROWS.
+    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_CHARACTERS_ARRAY  !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN COLUMNS OR ROWS.
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I1P   !< CAST STRING TO INTEGER.
+#ifndef _NVF
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I2P   !< CAST STRING TO INTEGER.
+#endif
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I4P   !< CAST STRING TO INTEGER.
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I8P   !< CAST STRING TO INTEGER.
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R4P      !< CAST STRING TO REAL.
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R8P      !< CAST STRING TO REAL.
+    PROCEDURE, PRIVATE, PASS(SELF) :: TO_REAL_R16P     !< CAST STRING TO REAL.
+    ! ASSIGNMENTS
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_STRING      !< ASSIGNMENT OPERATOR FROM STRING INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_CHARACTER   !< ASSIGNMENT OPERATOR FROM CHARACTER INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I1P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I2P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I4P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_INTEGER_I8P !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R4P    !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R8P    !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_ASSIGN_REAL_R16P   !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+    ! CONCATENATION OPERATORS
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_STRING           !< CONCATENATION WITH STRING.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_CHARACTER        !< CONCATENATION WITH CHARACTER.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_CONCAT_STRING        !< CONCATENATION WITH CHARACTER (INVERTED).
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_STRING_STRING    !< CONCATENATION WITH STRING (STRING OUTPUT).
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_CONCAT_CHARACTER_STRING !< CONCATENATION WITH CHARACTER (STRING OUTPUT).
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_CONCAT_STRING_STRING !< CONCATENATION WITH CHARACTER (INVERTED, STRING OUTPUT).
+    ! LOGICAL OPERATORS
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_EQ_STRING    !< EQUAL TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_EQ_CHARACTER !< EQUAL TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_EQ_STRING !< EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_NE_STRING    !< NOT EQUAL TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_NE_CHARACTER !< NOT EQUAL TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_NE_STRING !< NOT EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LT_STRING    !< LOWER THAN TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LT_CHARACTER !< LOWER THAN TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_LT_STRING !< LOWER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LE_STRING    !< LOWER EQUAL THAN TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_LE_CHARACTER !< LOWER EQUAL THAN TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_LE_STRING !< LOWER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GE_STRING    !< GREATER EQUAL THAN TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GE_CHARACTER !< GREATER EQUAL THAN TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_GE_STRING !< GREATER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GT_STRING    !< GREATER THAN TO STRING LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(LHS) :: STRING_GT_CHARACTER !< GREATER THAN TO CHARACTER LOGICAL OPERATOR.
+    PROCEDURE, PRIVATE, PASS(RHS) :: CHARACTER_GT_STRING !< GREATER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+    ! IO
+    PROCEDURE, PRIVATE, PASS(DTV) :: READ_FORMATTED                !< FORMATTED INPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: READ_DELIMITED                !< READ A DELIMITED INPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNDELIMITED              !< READ AN UNDELIMITED INPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNDELIMITED_LISTDIRECTED !< READ AN UNDELIMITED LIST DIRECTED INPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: WRITE_FORMATTED               !< FORMATTED OUTPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: READ_UNFORMATTED              !< UNFORMATTED INPUT.
+    PROCEDURE, PRIVATE, PASS(DTV) :: WRITE_UNFORMATTED             !< UNFORMATTED OUTPUT.
+    ! MISCELLANEA
+    PROCEDURE, PRIVATE, PASS(SELF) :: REPLACE_ONE_OCCURRENCE !< REPLACE THE FIRST OCCURRENCE OF SUBSTRING OLD BY NEW.
+ENDTYPE STRING
+
+! INTERNAL PARAMETERS
+CHARACTER(KIND=CK, LEN=26), PARAMETER :: UPPER_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET.
+CHARACTER(KIND=CK, LEN=26), PARAMETER :: LOWER_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET.
+CHARACTER(KIND=CK, LEN=1),  PARAMETER :: SPACE          = ' '                          !< SPACE CHARACTER.
+CHARACTER(KIND=CK, LEN=1),  PARAMETER :: TAB            = ACHAR(9)                     !< TAB CHARACTER.
+CHARACTER(KIND=CK, LEN=1),  PARAMETER :: UIX_DIR_SEP    = CHAR(47)                     !< UNIX/LINUX DIRECTORIES SEPARATOR (/).
+CHARACTER(KIND=CK, LEN=1),  PARAMETER :: BACKSLASH      = CHAR(92)                     !< BACKSLASH CHARACTER.
+
+INTERFACE GLOB
+  !< OVERLOADING GLOB PROCEDURE.
+  !<```FORTRAN
+  !< TYPE(STRING)                  :: ASTRING
+  !< CHARACTER(LEN=:), ALLOCATABLE :: ALIST_CHR(:)
+  !< TYPE(STRING),     ALLOCATABLE :: ALIST_STR(:)
+  !< INTEGER, PARAMETER            :: NF=5
+  !< CHARACTER(14)                 :: FILES(1:NF)
+  !< INTEGER                       :: FILE_UNIT
+  !< INTEGER                       :: F
+  !< INTEGER                       :: FF
+  !< LOGICAL                       :: TEST_PASSED
+  !< DO F=1, NF
+  !<    FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-')
+  !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+  !<    WRITE(FILE_UNIT, *)F
+  !<    CLOSE(UNIT=FILE_UNIT)
+  !< ENDDO
+  !< CALL GLOB(SELF=ASTRING, PATTERN='FOO-*', LIST=ALIST_CHR)
+  !< CALL GLOB(SELF=ASTRING, PATTERN='FOO-*', LIST=ALIST_STR)
+  !< DO F=1, NF
+  !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+  !<    CLOSE(UNIT=FILE_UNIT, STATUS='DELETE')
+  !< ENDDO
+  !< TEST_PASSED = .FALSE.
+  !< OUTER_CHR: DO F=1, SIZE(ALIST_CHR, DIM=1)
+  !<    DO FF=1, NF
+  !<       TEST_PASSED = ALIST_CHR(F) == FILES(FF)
+  !<       IF (TEST_PASSED) CYCLE OUTER_CHR
+  !<    ENDDO
+  !< ENDDO OUTER_CHR
+  !< IF (TEST_PASSED) THEN
+  !<    TEST_PASSED = .FALSE.
+  !<    OUTER_STR: DO F=1, SIZE(ALIST_STR, DIM=1)
+  !<       DO FF=1, NF
+  !<          TEST_PASSED = ALIST_STR(F) == FILES(FF)
+  !<          IF (TEST_PASSED) CYCLE OUTER_STR
+  !<       ENDDO
+  !<    ENDDO OUTER_STR
+  !< ENDIF
+  !< PRINT '(L1)', TEST_PASSED
+  !<```
+  !=> T <<<
+  MODULE PROCEDURE GLOB_CHARACTER, GLOB_STRING
+ENDINTERFACE GLOB
+
+INTERFACE STRJOIN
+  MODULE PROCEDURE STRJOIN_STRINGS, STRJOIN_CHARACTERS, STRJOIN_STRINGS_ARRAY, STRJOIN_CHARACTERS_ARRAY
+ENDINTERFACE STRJOIN
+
+! BUILTIN OVERLOADING
+INTERFACE ADJUSTL
+  !< BUILTIN ADJUSTL OVERLOADING.
+  MODULE PROCEDURE SADJUSTL_CHARACTER
+ENDINTERFACE ADJUSTL
+
+INTERFACE ADJUSTR
+  !< BUILTIN ADJUSTR OVERLOADING.
+  MODULE PROCEDURE SADJUSTR_CHARACTER
+ENDINTERFACE ADJUSTR
+
+INTERFACE COUNT
+  !< BUILTIN COUNT OVERLOADING.
+  MODULE PROCEDURE COUNT_SUBSTRING
+ENDINTERFACE
+
+INTERFACE INDEX
+  !< BUILTIN INDEX OVERLOADING.
+  MODULE PROCEDURE SINDEX_STRING_STRING, SINDEX_STRING_CHARACTER, SINDEX_CHARACTER_STRING
+ENDINTERFACE INDEX
+
+!INTERFACE LEN
+!  !< BUILTIN LEN OVERLOADING.
+!  MODULE PROCEDURE SLEN
+!ENDINTERFACE LEN
+
+INTERFACE LEN_TRIM
+  !< BUILTIN LEN_TRIM OVERLOADING.
+  MODULE PROCEDURE SLEN_TRIM
+ENDINTERFACE LEN_TRIM
+
+INTERFACE REPEAT
+  !< BUILTIN REPEAT OVERLOADING.
+  MODULE PROCEDURE SREPEAT_STRING_STRING
+ENDINTERFACE REPEAT
+
+INTERFACE SCAN
+  !< BUILTIN SCAN OVERLOADING.
+  MODULE PROCEDURE SSCAN_STRING_STRING, SSCAN_STRING_CHARACTER, SSCAN_CHARACTER_STRING
+ENDINTERFACE SCAN
+
+INTERFACE TRIM
+  !< BUILTIN TRIM OVERLOADING.
+  MODULE PROCEDURE STRIM
+ENDINTERFACE TRIM
+
+INTERFACE VERIFY
+  !< BUILTIN VERIFY OVERLOADING.
+  MODULE PROCEDURE SVERIFY_STRING_STRING, SVERIFY_STRING_CHARACTER, SVERIFY_CHARACTER_STRING
+ENDINTERFACE VERIFY
+
+CONTAINS
+   ! PUBLIC NON TBP
+
+   ! CREATOR
+   PURE FUNCTION STRING_(C)
+   !< RETURN A STRING GIVEN A CHARACTER INPUT.
+   !<
+   !<```FORTRAN
+   !< PRINT "(L1)", STRING('HELLO WORLD')//''=='HELLO WORLD'
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN) :: C       !< CHARACTER.
+   TYPE(STRING)             :: STRING_ !< STRING.
+
+   STRING_%RAW = C
+   ENDFUNCTION STRING_
+
+   ! BUILTINS REPLACEMENTS
+   PURE FUNCTION SADJUSTL_CHARACTER(S) RESULT(ADJUSTED)
+   !< LEFT ADJUST A STRING BY REMOVING LEADING SPACES (CHARACTER OUTPUT).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = '   HELLO WORLD!'
+   !< PRINT "(L1)", ADJUSTL(ASTRING)=='HELLO WORLD!   '
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: S        !< STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: ADJUSTED !< ADJUSTED STRING.
+
+   IF (ALLOCATED(S%RAW)) ADJUSTED = ADJUSTL(S%RAW)
+   ENDFUNCTION SADJUSTL_CHARACTER
+
+   PURE FUNCTION SADJUSTR_CHARACTER(S) RESULT(ADJUSTED)
+   !< RIGHT ADJUST A STRING BY REMOVING LEADING SPACES (CHARACTER OUTPUT).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HELLO WORLD!   '
+   !< PRINT "(L1)", ADJUSTR(ASTRING)=='   HELLO WORLD!'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: S        !< STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: ADJUSTED !< ADJUSTED STRING.
+
+   IF (ALLOCATED(S%RAW)) ADJUSTED = ADJUSTR(S%RAW)
+   ENDFUNCTION SADJUSTR_CHARACTER
+
+   ELEMENTAL FUNCTION COUNT_SUBSTRING(S, SUBSTRING) RESULT(NO)
+   !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING.
+   !<
+   !<```FORTRAN
+   !< PRINT "(L1)", COUNT('HELLO', SUBSTRING='LL')==1
+   !<```
+   !=> T <<<
+   CHARACTER(*), INTENT(IN) :: S         !< STRING.
+   CHARACTER(*), INTENT(IN) :: SUBSTRING !< SUBSTRING.
+   INTEGER(I4P)             :: NO        !< NUMBER OF OCCURRENCES.
+   INTEGER(I4P)             :: C1        !< COUNTERS.
+   INTEGER(I4P)             :: C2        !< COUNTERS.
+
+   NO = 0
+   IF (LEN(SUBSTRING) > LEN(S)) RETURN
+   C1 = 1
+   DO
+     C2 = INDEX(STRING=S(C1:), SUBSTRING=SUBSTRING)
+     IF (C2==0) RETURN
+     NO = NO + 1
+     C1 = C1 + C2 + LEN(SUBSTRING)
+   ENDDO
+   ENDFUNCTION COUNT_SUBSTRING
+
+   ELEMENTAL FUNCTION SINDEX_CHARACTER_STRING(S, SUBSTRING, BACK) RESULT(I)
+   !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE.
+   !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS
+   !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'LLO'
+   !< TEST_PASSED(1) = INDEX(S='HELLO WORLD HELLO!', SUBSTRING=STRING1)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO')
+   !< TEST_PASSED(2) = INDEX(S='HELLO WORLD HELLO!', SUBSTRING=STRING1, BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', &
+   !<                                                                                       SUBSTRING='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: S         !< STRING.
+   TYPE(STRING),              INTENT(IN)           :: SUBSTRING !< SEARCHED SUBSTRING.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK      !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I         !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SUBSTRING%RAW)) THEN
+     I = INDEX(STRING=S, SUBSTRING=SUBSTRING%RAW, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SINDEX_CHARACTER_STRING
+
+   ELEMENTAL FUNCTION SSCAN_CHARACTER_STRING(S, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'LLO'
+   !< TEST_PASSED(1) = SCAN(S='HELLO WORLD HELLO!', SET=STRING1)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = SCAN(S='HELLO WORLD HELLO!', SET=STRING1, BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', &
+   !<                                                                               SET='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: S    !< STRING.
+   TYPE(STRING),              INTENT(IN)           :: SET  !< SEARCHED SET.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I    !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SET%RAW)) THEN
+     I = SCAN(STRING=S, SET=SET%RAW, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SSCAN_CHARACTER_STRING
+
+   ELEMENTAL FUNCTION SVERIFY_CHARACTER_STRING(S, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT
+   !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'ELL'
+   !< TEST_PASSED(1) = VERIFY(S='HELLO WORLD HELLO!', SET=STRING1)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = VERIFY(S='HELLO WORLD HELLO!', SET=STRING1, BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', &
+   !<                                                                                   BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: S    !< STRING.
+   TYPE(STRING),              INTENT(IN)           :: SET  !< SEARCHED SET.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I    !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SET%RAW)) THEN
+     I = VERIFY(STRING=S, SET=SET%RAW, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SVERIFY_CHARACTER_STRING
+
+   ! PUBLIC METHODS
+
+   ! BUILTINS REPLACEMENTS
+   ELEMENTAL FUNCTION SADJUSTL(SELF) RESULT(ADJUSTED)
+   !< LEFT ADJUST A STRING BY REMOVING LEADING SPACES.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = '   HELLO WORLD!'
+   !< PRINT "(L1)", ASTRING%ADJUSTL()//''=='HELLO WORLD!   '
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   TYPE(STRING)              :: ADJUSTED !< ADJUSTED STRING.
+
+   ADJUSTED = SELF
+   IF (ALLOCATED(ADJUSTED%RAW)) ADJUSTED%RAW = ADJUSTL(ADJUSTED%RAW)
+   ENDFUNCTION SADJUSTL
+
+   ELEMENTAL FUNCTION SADJUSTR(SELF) RESULT(ADJUSTED)
+   !< RIGHT ADJUST A STRING BY REMOVING LEADING SPACES.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HELLO WORLD!   '
+   !< PRINT "(L1)", ASTRING%ADJUSTR()//''=='   HELLO WORLD!'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   TYPE(STRING)              :: ADJUSTED !< ADJUSTED STRING.
+
+   ADJUSTED = SELF
+   IF (ALLOCATED(ADJUSTED%RAW)) ADJUSTED%RAW = ADJUSTR(ADJUSTED%RAW)
+   ENDFUNCTION SADJUSTR
+
+   ELEMENTAL FUNCTION SCOUNT(SELF, SUBSTRING, IGNORE_ISOLATED) RESULT(NO)
+   !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING.
+   !<
+   !< @NOTE IF `IGNORE_ISOLATED` IS SET TO TRUE THE EVENTUAL "ISOLATED" OCCURENCES ARE IGNORED: AN ISOLATED OCCURRENCES ARE THOSE
+   !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING A
+   !< RIGHT COMPANION).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(4)
+   !< ASTRING = '   HELLO WORLD  !    '
+   !< TEST_PASSED(1) = ASTRING%COUNT(SUBSTRING=' ')==10
+   !< ASTRING = 'HELLO WORLD  !    '
+   !< TEST_PASSED(2) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==6
+   !< ASTRING = '    HELLO WORLD  !'
+   !< TEST_PASSED(3) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==6
+   !< ASTRING = '   HELLO WORLD  !    '
+   !< TEST_PASSED(4) = ASTRING%COUNT(SUBSTRING=' ', IGNORE_ISOLATED=.TRUE.)==8
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: SELF             !< THE STRING.
+   CHARACTER(*),  INTENT(IN)              :: SUBSTRING        !< SUBSTRING.
+   LOGICAL,       INTENT(IN), OPTIONAL    :: IGNORE_ISOLATED  !< IGNORE "ISOLATED" OCCURRENCES.
+   INTEGER                                :: NO               !< NUMBER OF OCCURRENCES.
+   LOGICAL                                :: IGNORE_ISOLATED_ !< IGNORE "ISOLATED" OCCURRENCES, LOCAL VARIABLE.
+   INTEGER                                :: C1               !< COUNTER.
+   INTEGER                                :: C2               !< COUNTER.
+
+   NO = 0
+   IF (ALLOCATED(SELF%RAW)) THEN
+      IF (LEN(SUBSTRING)>LEN(SELF%RAW)) RETURN
+      IGNORE_ISOLATED_ = .FALSE. ; IF (PRESENT(IGNORE_ISOLATED)) IGNORE_ISOLATED_ = IGNORE_ISOLATED
+      C1 = 1
+      DO
+         C2 = INDEX(STRING=SELF%RAW(C1:), SUBSTRING=SUBSTRING)
+         IF (C2==0) RETURN
+         IF (.NOT.IGNORE_ISOLATED_) THEN
+            NO = NO + 1
+         ELSE
+            IF (.NOT.((C1==1.AND.C2==1) .OR. (C1==LEN(SELF%RAW)-LEN(SUBSTRING)+1))) THEN
+               NO = NO + 1
+            ENDIF
+         ENDIF
+         C1 = C1 + C2 - 1 + LEN(SUBSTRING)
+      ENDDO
+   ENDIF
+   ENDFUNCTION SCOUNT
+
+   ELEMENTAL FUNCTION SINDEX_STRING_STRING(SELF, SUBSTRING, BACK) RESULT(I)
+   !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE.
+   !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS
+   !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< TYPE(STRING) :: STRING2
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< STRING2 = 'LLO'
+   !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING=STRING2)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO')
+   !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING=STRING2, BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', &
+   !<                                                                       BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF      !< THE STRING.
+   TYPE(STRING),  INTENT(IN)           :: SUBSTRING !< SEARCHED SUBSTRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: BACK      !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                             :: I         !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      I = INDEX(STRING=SELF%RAW, SUBSTRING=SUBSTRING%RAW, BACK=BACK)
+   ELSE
+      I = 0
+   ENDIF
+   ENDFUNCTION SINDEX_STRING_STRING
+
+   ELEMENTAL FUNCTION SINDEX_STRING_CHARACTER(SELF, SUBSTRING, BACK) RESULT(I)
+   !< RETURN THE POSITION OF THE START OF THE FIRST OCCURRENCE OF STRING `SUBSTRING` AS A SUBSTRING IN `STRING`, COUNTING FROM ONE.
+   !< IF `SUBSTRING` IS NOT PRESENT IN `STRING`, ZERO IS RETURNED. IF THE BACK ARGUMENT IS PRESENT AND TRUE, THE RETURN VALUE IS
+   !< THE START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING='LLO')==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO')
+   !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO', BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: SUBSTRING !< SEARCHED SUBSTRING.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK      !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I         !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      I = INDEX(STRING=SELF%RAW, SUBSTRING=SUBSTRING, BACK=BACK)
+   ELSE
+      I = 0
+   ENDIF
+   ENDFUNCTION SINDEX_STRING_CHARACTER
+
+   ELEMENTAL FUNCTION SLEN(SELF) RESULT(L)
+   !< RETURN THE LENGTH OF A STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HELLO WORLD!   '
+   !< PRINT "(L1)", ASTRING%LEN()==LEN('HELLO WORLD!   ')
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF !< THE STRING.
+   INTEGER                   :: L    !< STRING LENGTH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      L = LEN(STRING=SELF%RAW)
+   ELSE
+      L = 0
+   ENDIF
+   ENDFUNCTION SLEN
+
+   ELEMENTAL FUNCTION SLEN_TRIM(SELF) RESULT(L)
+   !< RETURN THE LENGTH OF A STRING, IGNORING ANY TRAILING BLANKS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HELLO WORLD!   '
+   !< PRINT "(L1)", ASTRING%LEN_TRIM()==LEN_TRIM('HELLO WORLD!   ')
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF !< THE STRING.
+   INTEGER                   :: L    !< STRING LENGTH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      L = LEN_TRIM(STRING=SELF%RAW)
+   ELSE
+      L = 0
+   ENDIF
+   ENDFUNCTION SLEN_TRIM
+
+   ELEMENTAL FUNCTION SREPEAT_STRING_STRING(SELF, NCOPIES) RESULT(REPEATED)
+   !< CONCATENATES SEVERAL COPIES OF AN INPUT STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'X'
+   !< PRINT "(L1)", ASTRING%REPEAT(5)//''=='XXXXX'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< STRING TO BE REPEATED.
+   INTEGER,       INTENT(IN) :: NCOPIES  !< NUMBER OF STRING COPIES.
+   TYPE(STRING)              :: REPEATED !< REPEATED STRING.
+#ifdef _NVF
+   CHARACTER(9999)           :: NVF_BUG  !< WORK AROUND FOR NVFORTRAN BUG.
+#endif
+
+#ifdef _NVF
+   NVF_BUG = SELF%RAW
+   REPEATED%RAW = REPEAT(STRING=TRIM(NVF_BUG), NCOPIES=NCOPIES)
+#else
+   REPEATED%RAW = REPEAT(STRING=SELF%RAW, NCOPIES=NCOPIES)
+#endif
+   ENDFUNCTION SREPEAT_STRING_STRING
+
+   ELEMENTAL FUNCTION SREPEAT_CHARACTER_STRING(RSTRING, NCOPIES) RESULT(REPEATED)
+   !< CONCATENATES SEVERAL COPIES OF AN INPUT STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'Y'
+   !< PRINT "(L1)", ASTRING%REPEAT('X', 5)//''=='XXXXX'
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RSTRING  !< STRING TO BE REPEATED.
+   INTEGER,                   INTENT(IN) :: NCOPIES  !< NUMBER OF STRING COPIES.
+   TYPE(STRING)                          :: REPEATED !< REPEATED STRING.
+
+   REPEATED%RAW = REPEAT(STRING=RSTRING, NCOPIES=NCOPIES)
+   ENDFUNCTION SREPEAT_CHARACTER_STRING
+
+   ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< TYPE(STRING) :: STRING2
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< STRING2 = 'LLO'
+   !< TEST_PASSED(1) = STRING1%SCAN(SET=STRING2)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = STRING1%SCAN(SET=STRING2, BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF  !< THE STRING.
+   TYPE(STRING),  INTENT(IN)           :: SET   !< SEARCHED SET.
+   LOGICAL,       INTENT(IN), OPTIONAL :: BACK  !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                             :: I     !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW).AND.ALLOCATED(SET%RAW)) THEN
+     I = SCAN(STRING=SELF%RAW, SET=SET%RAW, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SSCAN_STRING_STRING
+
+   ELEMENTAL FUNCTION SSCAN_STRING_CHARACTER(SELF, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< TEST_PASSED(1) = STRING1%SCAN(SET='LLO')==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = STRING1%SCAN(SET='LLO', BACK=.TRUE.)==SCAN(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF  !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: SET   !< SEARCHED SET.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK  !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I     !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     I = SCAN(STRING=SELF%RAW, SET=SET, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SSCAN_STRING_CHARACTER
+
+   ELEMENTAL FUNCTION STRIM(SELF) RESULT(TRIMMED)
+   !< REMOVE TRAILING SPACES.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HELLO WORLD!   '
+   !< PRINT "(L1)", ASTRING%TRIM()==TRIM('HELLO WORLD!   ')
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF    !< THE STRING.
+   TYPE(STRING)              :: TRIMMED !< TRIMMED STRING.
+
+   TRIMMED = SELF
+   IF (ALLOCATED(TRIMMED%RAW)) TRIMMED%RAW = TRIM(TRIMMED%RAW)
+   ENDFUNCTION STRIM
+
+   ELEMENTAL FUNCTION SVERIFY_STRING_STRING(SELF, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT
+   !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< TYPE(STRING) :: STRING2
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< STRING2 = 'LLO'
+   !< TEST_PASSED(1) = STRING1%VERIFY(SET=STRING2)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = STRING1%VERIFY(SET=STRING2, BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF  !< THE STRING.
+   TYPE(STRING),  INTENT(IN)           :: SET   !< SEARCHED SET.
+   LOGICAL,       INTENT(IN), OPTIONAL :: BACK  !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                             :: I     !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW).AND.ALLOCATED(SET%RAW)) THEN
+     I = VERIFY(STRING=SELF%RAW, SET=SET%RAW, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SVERIFY_STRING_STRING
+
+   ELEMENTAL FUNCTION SVERIFY_STRING_CHARACTER(SELF, SET, BACK) RESULT(I)
+   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS NOT
+   !< IN `SET`. IF ALL CHARACTERS OF `STRING` ARE FOUND IN `SET`, THE RESULT IS ZERO.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< STRING1 = 'HELLO WORLD HELLO!'
+   !< TEST_PASSED(1) = STRING1%VERIFY(SET='LLO')==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO')
+   !< TEST_PASSED(2) = STRING1%VERIFY(SET='LLO', BACK=.TRUE.)==VERIFY(STRING='HELLO WORLD HELLO!', SET='LLO', BACK=.TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF  !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: SET   !< SEARCHED SET.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: BACK  !< START OF THE LAST OCCURRENCE RATHER THAN THE FIRST.
+   INTEGER                                         :: I     !< RESULT OF THE SEARCH.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     I = VERIFY(STRING=SELF%RAW, SET=SET, BACK=BACK)
+   ELSE
+     I = 0
+   ENDIF
+   ENDFUNCTION SVERIFY_STRING_CHARACTER
+
+   ! AUXILIARY METHODS
+   ELEMENTAL FUNCTION BASEDIR(SELF, SEP)
+   !< RETURN THE BASE DIRECTORY NAME OF A STRING CONTAINING A FILE NAME.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: STRING1
+   !< LOGICAL      :: TEST_PASSED(4)
+   !< STRING1 = '/BAR/FOO.TAR.BZ2'
+   !< TEST_PASSED(1) = STRING1%BASEDIR()//''=='/BAR'
+   !< STRING1 = './BAR/FOO.TAR.BZ2'
+   !< TEST_PASSED(2) = STRING1%BASEDIR()//''=='./BAR'
+   !< STRING1 = 'BAR/FOO.TAR.BZ2'
+   !< TEST_PASSED(3) = STRING1%BASEDIR()//''=='BAR'
+   !< STRING1 = '\BAR\FOO.TAR.BZ2'
+   !< TEST_PASSED(4) = STRING1%BASEDIR(SEP='\')//''=='\BAR'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF    !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP     !< DIRECTORY SEPARATOR.
+   TYPE(STRING)                                    :: BASEDIR !< BASE DIRECTORY NAME.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_    !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: POS     !< CHARACTER POSITION.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     SEP_ = UIX_DIR_SEP ; IF (PRESENT(SEP)) SEP_ = SEP
+     BASEDIR = SELF
+     POS = INDEX(SELF%RAW, SEP_, BACK=.TRUE.)
+     IF (POS>0) BASEDIR%RAW = SELF%RAW(1:POS-1)
+   ENDIF
+   ENDFUNCTION BASEDIR
+
+   ELEMENTAL FUNCTION BASENAME(SELF, SEP, EXTENSION, STRIP_LAST_EXTENSION)
+   !< RETURN THE BASE FILE NAME OF A STRING CONTAINING A FILE NAME.
+   !<
+   !< OPTIONALLY, THE EXTENSION IS ALSO STRIPPED IF PROVIDED OR THE LAST ONE IF REQUIRED, E.G.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(5)
+   !< ASTRING = 'BAR/FOO.TAR.BZ2'
+   !< TEST_PASSED(1) = ASTRING%BASENAME()//''=='FOO.TAR.BZ2'
+   !< TEST_PASSED(2) = ASTRING%BASENAME(EXTENSION='.TAR.BZ2')//''=='FOO'
+   !< TEST_PASSED(3) = ASTRING%BASENAME(STRIP_LAST_EXTENSION=.TRUE.)//''=='FOO.TAR'
+   !< ASTRING = '\BAR\FOO.TAR.BZ2'
+   !< TEST_PASSED(4) = ASTRING%BASENAME(SEP='\')//''=='FOO.TAR.BZ2'
+   !< ASTRING = 'BAR'
+   !< TEST_PASSED(5) = ASTRING%BASENAME(STRIP_LAST_EXTENSION=.TRUE.)//''=='BAR'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF                 !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP                  !< DIRECTORY SEPARATOR.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: EXTENSION            !< FILE EXTENSION.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: STRIP_LAST_EXTENSION !< FLAG TO ENABLE THE STRIPPING OF LAST EXTENSION.
+   TYPE(STRING)                                    :: BASENAME             !< BASE FILE NAME.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_                 !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: POS                  !< CHARACTER POSITION.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SEP_ = UIX_DIR_SEP ; IF (PRESENT(SEP)) SEP_ = SEP
+      BASENAME = SELF
+      POS = INDEX(BASENAME%RAW, SEP_, BACK=.TRUE.)
+      IF (POS>0) BASENAME%RAW = SELF%RAW(POS+1:)
+      IF (PRESENT(EXTENSION)) THEN
+         POS = INDEX(BASENAME%RAW, EXTENSION, BACK=.TRUE.)
+         IF (POS>0) BASENAME%RAW = BASENAME%RAW(1:POS-1)
+      ELSEIF (PRESENT(STRIP_LAST_EXTENSION)) THEN
+         IF (STRIP_LAST_EXTENSION) THEN
+            POS = INDEX(BASENAME%RAW, '.', BACK=.TRUE.)
+            IF (POS>0) BASENAME%RAW = BASENAME%RAW(1:POS-1)
+         ENDIF
+      ENDIF
+   ENDIF
+   ENDFUNCTION BASENAME
+
+   ELEMENTAL FUNCTION CAMELCASE(SELF, SEP)
+   !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES.
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'CAMEL CASE VAR'
+   !< PRINT '(L1)', ASTRING%CAMELCASE()//''=='CAMELCASEVAR'
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: CAMELCASE !< CAMEL CASE STRING.
+   TYPE(STRING), ALLOCATABLE                       :: TOKENS(:) !< STRING TOKENS.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP)
+     TOKENS = TOKENS%CAPITALIZE()
+     CAMELCASE = CAMELCASE%JOIN(ARRAY=TOKENS)
+   ENDIF
+   ENDFUNCTION CAMELCASE
+
+   ELEMENTAL FUNCTION CAPITALIZE(SELF) RESULT(CAPITALIZED)
+   !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'SAY ALL HELLO WORLD!'
+   !< PRINT '(L1)', ASTRING%CAPITALIZE()//''=='SAY ALL HELLO WORLD!'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF        !< THE STRING.
+   TYPE(STRING)              :: CAPITALIZED !< UPPER CASE STRING.
+   INTEGER                   :: C           !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     CAPITALIZED = SELF%LOWER()
+     C = INDEX(LOWER_ALPHABET, CAPITALIZED%RAW(1:1))
+     IF (C>0) CAPITALIZED%RAW(1:1) = UPPER_ALPHABET(C:C)
+   ENDIF
+   ENDFUNCTION CAPITALIZE
+
+   PURE FUNCTION CHARS(SELF) RESULT(RAW)
+   !< RETURN THE RAW CHARACTERS DATA.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'SAY ALL HELLO WORLD!'
+   !< PRINT '(L1)', ASTRING%CHARS()=='SAY ALL HELLO WORLD!'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: SELF !< THE STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW  !< RAW CHARACTERS DATA.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     RAW = SELF%RAW
+   ELSE
+     RAW = ''
+   ENDIF
+   ENDFUNCTION CHARS
+
+   PURE FUNCTION COLORIZE_STR(SELF, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
+   !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'SAY ALL HELLO WORLD!'
+   !< PRINT '(L1)', ASTRING%COLORIZE(COLOR_FG='RED')=='SAY ALL HELLO WORLD!'
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
+   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
+   CHARACTER(LEN=:), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
+
+   COLORIZED = COLORIZE(STRING=SELF%CHARS(), COLOR_FG=COLOR_FG, COLOR_BG=COLOR_BG, STYLE=STYLE)
+   ENDFUNCTION COLORIZE_STR
+
+   ELEMENTAL FUNCTION DECODE(SELF, CODEC) RESULT(DECODED)
+   !< RETURN A STRING DECODED ACCORDINGLY THE CODEC.
+   !<
+   !< @NOTE ONLY BASE64 CODEC IS CURRENTLY AVAILABLE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'SG93IGFYZSB5B3U/'
+   !< PRINT '(L1)', ASTRING%DECODE(CODEC='BASE64')//''=='HOW ARE YOU?'
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: SELF    !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: CODEC   !< ENCODING CODEC.
+   TYPE(STRING)                          :: DECODED !< DECODED STRING.
+   TYPE(STRING)                          :: CODEC_U !< ENCODING CODEC IN UPPER CASE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     DECODED = SELF
+     CODEC_U = CODEC
+     SELECT CASE(CODEC_U%UPPER()//'')
+     CASE('BASE64')
+       CALL B64_DECODE(CODE=SELF%RAW, S=DECODED%RAW)
+     ENDSELECT
+     DECODED = DECODED%STRIP(REMOVE_NULLS=.TRUE.)
+   ENDIF
+   ENDFUNCTION DECODE
+
+   ELEMENTAL FUNCTION ENCODE(SELF, CODEC) RESULT(ENCODED)
+   !< RETURN A STRING ENCODED ACCORDINGLY THE CODEC.
+   !<
+   !< @NOTE ONLY BASE64 CODEC IS CURRENTLY AVAILABLE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'HOW ARE YOU?'
+   !< PRINT '(L1)', ASTRING%ENCODE(CODEC='BASE64')//''=='SG93IGFYZSB5B3U/'
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: SELF    !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: CODEC   !< ENCODING CODEC.
+   TYPE(STRING)                          :: ENCODED !< ENCODED STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     ENCODED = CODEC
+     SELECT CASE(ENCODED%UPPER()//'')
+     CASE('BASE64')
+       CALL B64_ENCODE(S=SELF%RAW, CODE=ENCODED%RAW)
+     ENDSELECT
+   ENDIF
+   ENDFUNCTION ENCODE
+
+   ELEMENTAL FUNCTION ESCAPE(SELF, TO_ESCAPE, ESC) RESULT(ESCAPED)
+   !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = '^\S \D+\S*'
+   !< TEST_PASSED(1) = ASTRING%ESCAPE(TO_ESCAPE='\')//''=='^\\S \\D+\\S*'
+   !< TEST_PASSED(2) = ASTRING%ESCAPE(TO_ESCAPE='\', ESC='|')//''=='^|\S |\D+|\S*'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=1), INTENT(IN)           :: TO_ESCAPE !< CHARACTER TO BE ESCAPED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: ESC       !< CHARACTER USED TO ESCAPE.
+   TYPE(STRING)                                    :: ESCAPED   !< ESCAPED STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: ESC_      !< CHARACTER TO ESCAPE, LOCAL VARIABLE.
+   INTEGER                                         :: C         !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     ESC_ = BACKSLASH ; IF (PRESENT(ESC)) ESC_ = ESC
+     ESCAPED%RAW = ''
+     DO C=1, LEN(SELF%RAW)
+       IF (SELF%RAW(C:C)==TO_ESCAPE) THEN
+         ESCAPED%RAW = ESCAPED%RAW//ESC_//TO_ESCAPE
+       ELSE
+         ESCAPED%RAW = ESCAPED%RAW//SELF%RAW(C:C)
+       ENDIF
+     ENDDO
+   ENDIF
+   ENDFUNCTION ESCAPE
+
+   ELEMENTAL FUNCTION EXTENSION(SELF)
+   !< RETURN THE EXTENSION OF A STRING CONTAINING A FILE NAME.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = '/BAR/FOO.TAR.BZ2'
+   !< PRINT '(L1)', ASTRING%EXTENSION()//''=='.BZ2'
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: SELF      !< THE STRING.
+   TYPE(STRING)                           :: EXTENSION !< EXTENSION FILE NAME.
+   INTEGER                                :: POS       !< CHARACTER POSITION.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      EXTENSION = ''
+      POS = INDEX(SELF%RAW, '.', BACK=.TRUE.)
+      IF (POS>0) EXTENSION%RAW = SELF%RAW(POS:)
+   ENDIF
+   ENDFUNCTION EXTENSION
+
+   ELEMENTAL FUNCTION FILL(SELF, WIDTH, RIGHT, FILLING_CHAR) RESULT(FILLED)
+   !< PAD STRING ON THE LEFT (OR RIGHT) WITH ZEROS (OR OTHER CHAR) TO FILL WIDTH.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(4)
+   !< ASTRING = 'THIS IS STRING EXAMPLE....WOW!!!'
+   !< TEST_PASSED(1) = ASTRING%FILL(WIDTH=40)//''=='00000000THIS IS STRING EXAMPLE....WOW!!!'
+   !< TEST_PASSED(2) = ASTRING%FILL(WIDTH=50)//''=='000000000000000000THIS IS STRING EXAMPLE....WOW!!!'
+   !< TEST_PASSED(3) = ASTRING%FILL(WIDTH=50, RIGHT=.TRUE.)//''=='THIS IS STRING EXAMPLE....WOW!!!000000000000000000'
+   !< TEST_PASSED(4) = ASTRING%FILL(WIDTH=40, FILLING_CHAR='*')//''=='********THIS IS STRING EXAMPLE....WOW!!!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF          !< THE STRING.
+   INTEGER,                   INTENT(IN)           :: WIDTH         !< FINAL WIDTH OF FILLED STRING.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: RIGHT         !< FILL ON THE RIGHT INSTEAD OF LEFT.
+   CHARACTER(KIND=CK, LEN=1), INTENT(IN), OPTIONAL :: FILLING_CHAR  !< FILLING CHARACTER (DEFAULT "0").
+   TYPE(STRING)                                    :: FILLED        !< FILLED STRING.
+   LOGICAL                                         :: RIGHT_        !< FILL ON THE RIGHT INSTEAD OF LEFT, LOCAL VARIABLE.
+   CHARACTER(KIND=CK, LEN=1)                       :: FILLING_CHAR_ !< FILLING CHARACTER (DEFAULT "0"), LOCAL VARIABLE.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      IF (WIDTH>LEN(SELF%RAW)) THEN
+         RIGHT_ = .FALSE. ; IF (PRESENT(RIGHT)) RIGHT_ = RIGHT
+         FILLING_CHAR_ = '0' ; IF (PRESENT(FILLING_CHAR)) FILLING_CHAR_ = FILLING_CHAR
+         IF (.NOT.RIGHT_) THEN
+            FILLED%RAW = REPEAT(FILLING_CHAR_, WIDTH-LEN(SELF%RAW))//SELF%RAW
+         ELSE
+            FILLED%RAW = SELF%RAW//REPEAT(FILLING_CHAR_, WIDTH-LEN(SELF%RAW))
+         ENDIF
+      ENDIF
+   ENDIF
+   ENDFUNCTION FILL
+
+   ELEMENTAL SUBROUTINE FREE(SELF)
+   !< FREE DYNAMIC MEMORY.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'THIS IS STRING EXAMPLE....WOW!!!'
+   !< CALL ASTRING%FREE
+   !< PRINT '(L1)', ASTRING%IS_ALLOCATED().EQV..FALSE.
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: SELF !< THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) DEALLOCATE(SELF%RAW)
+   ENDSUBROUTINE FREE
+
+   SUBROUTINE GLOB_CHARACTER(SELF, PATTERN, LIST)
+   !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL.
+   !<
+   !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ALIST_CHR(:)
+   !< INTEGER, PARAMETER            :: NF=5
+   !< CHARACTER(14)                 :: FILES(1:NF)
+   !< INTEGER                       :: FILE_UNIT
+   !< INTEGER                       :: F
+   !< INTEGER                       :: FF
+   !< LOGICAL                       :: TEST_PASSED
+   !< DO F=1, NF
+   !<    FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-')
+   !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+   !<    WRITE(FILE_UNIT, *)F
+   !<    CLOSE(UNIT=FILE_UNIT)
+   !< ENDDO
+   !< CALL ASTRING%GLOB(PATTERN='FOO-*', LIST=ALIST_CHR)
+   !< DO F=1, NF
+   !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+   !<    CLOSE(UNIT=FILE_UNIT, STATUS='DELETE')
+   !< ENDDO
+   !< TEST_PASSED = .FALSE.
+   !< OUTER_CHR: DO F=1, SIZE(ALIST_CHR, DIM=1)
+   !<    DO FF=1, NF
+   !<       TEST_PASSED = ALIST_CHR(F) == FILES(FF)
+   !<       IF (TEST_PASSED) CYCLE OUTER_CHR
+   !<    ENDDO
+   !< ENDDO OUTER_CHR
+   !< PRINT '(L1)', TEST_PASSED
+   !<```
+   !=> T <<<
+   CLASS(STRING),                 INTENT(IN)  :: SELF           !< THE STRING.
+   CHARACTER(*),                  INTENT(IN)  :: PATTERN        !< GIVEN PATTERN.
+   CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: LIST(:)        !< LIST OF MATCHING PATHNAMES.
+   TYPE(STRING), ALLOCATABLE                  :: LIST_(:)       !< LIST OF MATCHING PATHNAMES.
+   INTEGER(I4P)                               :: MAX_LEN        !< MAXIMUM LENGTH.
+   INTEGER(I4P)                               :: MATCHES_NUMBER !< MATCHES NUMBER.
+   INTEGER(I4P)                               :: M              !< COUNTER.
+
+   CALL SELF%GLOB(PATTERN=PATTERN, LIST=LIST_)
+   IF (ALLOCATED(LIST_)) THEN
+      MATCHES_NUMBER = SIZE(LIST_, DIM=1)
+      MAX_LEN = 0
+      DO M=1, MATCHES_NUMBER
+         MAX_LEN = MAX(MAX_LEN, LIST_(M)%LEN())
+      ENDDO
+      ALLOCATE(CHARACTER(MAX_LEN) :: LIST(1:MATCHES_NUMBER))
+      DO M=1, MATCHES_NUMBER
+         LIST(M) = LIST_(M)%CHARS()
+      ENDDO
+   ENDIF
+   ENDSUBROUTINE GLOB_CHARACTER
+
+   SUBROUTINE GLOB_STRING(SELF, PATTERN, LIST)
+   !< GLOB SEARCH (STRING OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL.
+   !<
+   !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< TYPE(STRING),     ALLOCATABLE :: ALIST_STR(:)
+   !< INTEGER, PARAMETER            :: NF=5
+   !< CHARACTER(14)                 :: FILES(1:NF)
+   !< INTEGER                       :: FILE_UNIT
+   !< INTEGER                       :: F
+   !< INTEGER                       :: FF
+   !< LOGICAL                       :: TEST_PASSED
+   !<
+   !< DO F=1, NF
+   !<    FILES(F) = ASTRING%TEMPNAME(PREFIX='FOO-')
+   !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+   !<    WRITE(FILE_UNIT, *)F
+   !<    CLOSE(UNIT=FILE_UNIT)
+   !< ENDDO
+   !< CALL ASTRING%GLOB(PATTERN='FOO-*', LIST=ALIST_STR)
+   !< DO F=1, NF
+   !<    OPEN(NEWUNIT=FILE_UNIT, FILE=FILES(F))
+   !<    CLOSE(UNIT=FILE_UNIT, STATUS='DELETE')
+   !< ENDDO
+   !< TEST_PASSED = .FALSE.
+   !< OUTER_STR: DO F=1, SIZE(ALIST_STR, DIM=1)
+   !<    DO FF=1, NF
+   !<       TEST_PASSED = ALIST_STR(F) == FILES(FF)
+   !<       IF (TEST_PASSED) CYCLE OUTER_STR
+   !<    ENDDO
+   !< ENDDO OUTER_STR
+   !< PRINT '(L1)', TEST_PASSED
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)  :: SELF     !< THE STRING.
+   CHARACTER(*),              INTENT(IN)  :: PATTERN  !< GIVEN PATTERN.
+   TYPE(STRING), ALLOCATABLE, INTENT(OUT) :: LIST(:)  !< LIST OF MATCHING PATHNAMES.
+   TYPE(STRING)                           :: TEMPFILE !< SAFE TEMPORARY FILE.
+   CHARACTER(LEN=:), ALLOCATABLE          :: TEMPNAME !< SAFE TEMPORARY NAME.
+   INTEGER(I4P)                           :: TEMPUNIT !< UNIT OF TEMPORARY FILE.
+
+   TEMPNAME = SELF%TEMPNAME()
+   CALL EXECUTE_COMMAND_LINE('LS -1 '//TRIM(ADJUSTL(PATTERN))//' > '//TEMPNAME)
+   CALL TEMPFILE%READ_FILE(FILE=TEMPNAME)
+   CALL TEMPFILE%SPLIT(SEP=NEW_LINE('A'), TOKENS=LIST)
+   OPEN(NEWUNIT=TEMPUNIT, FILE=TEMPNAME)
+   CLOSE(UNIT=TEMPUNIT, STATUS='DELETE')
+   ENDSUBROUTINE GLOB_STRING
+
+   ELEMENTAL FUNCTION INSERT_CHARACTER(SELF, SUBSTRING, POS) RESULT(INSERTED)
+   !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(5)
+   !< ASTRING = 'THIS IS STRING EXAMPLE WOW!!!'
+   !< ACHARACTER = '... '
+   !< TEST_PASSED(1) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=1)//''=='... THIS IS STRING EXAMPLE WOW!!!'
+   !< TEST_PASSED(2) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=23)//''=='THIS IS STRING EXAMPLE...  WOW!!!'
+   !< TEST_PASSED(3) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=29)//''=='THIS IS STRING EXAMPLE WOW!!!... '
+   !< TEST_PASSED(4) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=-1)//''=='... THIS IS STRING EXAMPLE WOW!!!'
+   !< TEST_PASSED(5) = ASTRING%INSERT(SUBSTRING=ACHARACTER, POS=100)//''=='THIS IS STRING EXAMPLE WOW!!!... '
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(IN) :: SELF      !< THE STRING.
+   CHARACTER(LEN=*), INTENT(IN) :: SUBSTRING !< SUBSTRING.
+   INTEGER,          INTENT(IN) :: POS       !< POSITION FROM WHICH INSERT SUBSTRING.
+   TYPE(STRING)                 :: INSERTED  !< INSERTED STRING.
+   INTEGER                      :: SAFEPOS   !< SAFE POSITION FROM WHICH INSERT SUBSTRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      INSERTED = SELF
+      SAFEPOS = MIN(MAX(1, POS), LEN(SELF%RAW))
+      IF (SAFEPOS==1) THEN
+         INSERTED%RAW = SUBSTRING//SELF%RAW
+      ELSEIF (SAFEPOS==LEN(SELF%RAW)) THEN
+         INSERTED%RAW = SELF%RAW//SUBSTRING
+      ELSE
+         INSERTED%RAW = SELF%RAW(1:SAFEPOS-1)//SUBSTRING//SELF%RAW(SAFEPOS:)
+      ENDIF
+   ELSE
+      INSERTED%RAW = SUBSTRING
+   ENDIF
+   ENDFUNCTION INSERT_CHARACTER
+
+   ELEMENTAL FUNCTION INSERT_STRING(SELF, SUBSTRING, POS) RESULT(INSERTED)
+   !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(5)
+   !< ASTRING = 'THIS IS STRING EXAMPLE WOW!!!'
+   !< ANOTHERSTRING = '... '
+   !< TEST_PASSED(1) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=1)//''=='... THIS IS STRING EXAMPLE WOW!!!'
+   !< TEST_PASSED(2) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=23)//''=='THIS IS STRING EXAMPLE...  WOW!!!'
+   !< TEST_PASSED(3) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=29)//''=='THIS IS STRING EXAMPLE WOW!!!... '
+   !< TEST_PASSED(4) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=-1)//''=='... THIS IS STRING EXAMPLE WOW!!!'
+   !< TEST_PASSED(5) = ASTRING%INSERT(SUBSTRING=ANOTHERSTRING, POS=100)//''=='THIS IS STRING EXAMPLE WOW!!!... '
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   TYPE(STRING),  INTENT(IN) :: SUBSTRING !< SUBSTRING.
+   INTEGER,       INTENT(IN) :: POS       !< POSITION FROM WHICH INSERT SUBSTRING.
+   TYPE(STRING)              :: INSERTED  !< INSERTED STRING.
+   INTEGER                   :: SAFEPOS   !< SAFE POSITION FROM WHICH INSERT SUBSTRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      INSERTED = SELF
+      IF (ALLOCATED(SUBSTRING%RAW)) THEN
+         SAFEPOS = MIN(MAX(1, POS), LEN(SELF%RAW))
+         IF (SAFEPOS==1) THEN
+            INSERTED%RAW = SUBSTRING%RAW//SELF%RAW
+         ELSEIF (SAFEPOS==LEN(SELF%RAW)) THEN
+            INSERTED%RAW = SELF%RAW//SUBSTRING%RAW
+         ELSE
+            INSERTED%RAW = SELF%RAW(1:SAFEPOS-1)//SUBSTRING%RAW//SELF%RAW(SAFEPOS:)
+         ENDIF
+      ENDIF
+   ELSE
+      IF (ALLOCATED(SUBSTRING%RAW)) INSERTED%RAW = SUBSTRING%RAW
+   ENDIF
+   ENDFUNCTION INSERT_STRING
+
+   PURE FUNCTION JOIN_STRINGS(SELF, ARRAY, SEP) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO SELF IF SELF HAS A VALUE OR IT IS SET TO A NULL STRING ''. THIS VALUE CAN BE OVERRIDDEN
+   !< PASSING A CUSTOM SEPARATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: STRINGS(3)
+   !< LOGICAL      :: TEST_PASSED(5)
+   !< STRINGS(1) = 'ONE'
+   !< STRINGS(2) = 'TWO'
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(1) = (ASTRING%JOIN(ARRAY=STRINGS)//''==STRINGS(1)//STRINGS(2)//STRINGS(3))
+   !< TEST_PASSED(2) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)//'-'//STRINGS(3))
+   !< CALL STRINGS(1)%FREE
+   !< STRINGS(2) = 'TWO'
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(3) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(2)//'-'//STRINGS(3))
+   !< STRINGS(1) = 'ONE'
+   !< STRINGS(2) = 'TWO'
+   !< CALL STRINGS(3)%FREE
+   !< TEST_PASSED(4) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2))
+   !< STRINGS(1) = 'ONE'
+   !< CALL STRINGS(2)%FREE
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(5) = (ASTRING%JOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(3))
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   TYPE(STRING),              INTENT(IN)           :: ARRAY(1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: JOIN      !< THE JOIN OF ARRAY.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: A         !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SEP_ = SELF%RAW
+   ELSE
+      SEP_ = ''
+   ENDIF
+   IF (PRESENT(SEP)) SEP_ = SEP
+   JOIN = ''
+   DO A=2, SIZE(ARRAY, DIM=1)
+      IF (ALLOCATED(ARRAY(A)%RAW)) JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)%RAW
+   ENDDO
+   IF (ALLOCATED(ARRAY(1)%RAW)) THEN
+      JOIN%RAW = ARRAY(1)%RAW//JOIN%RAW
+   ELSE
+      JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW))
+   ENDIF
+   ENDFUNCTION JOIN_STRINGS
+
+   PURE FUNCTION JOIN_CHARACTERS(SELF, ARRAY, SEP) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF CHARACTERS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO SELF IF SELF HAS A VALUE OR IT IS SET TO A NULL STRING ''. THIS VALUE CAN BE OVERRIDDEN
+   !< PASSING A CUSTOM SEPARATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< CHARACTER(5) :: CHARACTERS(3)
+   !< LOGICAL      :: TEST_PASSED(6)
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(1) = (ASTRING%JOIN(ARRAY=CHARACTERS)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3))
+   !< TEST_PASSED(2) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3))
+   !< CHARACTERS(1) = ''
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(3) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(2)//'-'//CHARACTERS(3))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = ''
+   !< TEST_PASSED(4) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(2))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = ''
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(5) = (ASTRING%JOIN(ARRAY=CHARACTERS, SEP='-')//''==CHARACTERS(1)//'-'//CHARACTERS(3))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< ASTRING = '_'
+   !< TEST_PASSED(6) = (ASTRING%JOIN(ARRAY=CHARACTERS)//''==CHARACTERS(1)//'_'//CHARACTERS(2)//'_'//CHARACTERS(3))
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: ARRAY(1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: JOIN      !< THE JOIN OF ARRAY.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: A         !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SEP_ = SELF%RAW
+   ELSE
+      SEP_ = ''
+   ENDIF
+   IF (PRESENT(SEP)) SEP_ = SEP
+   JOIN = ''
+   DO A=2, SIZE(ARRAY, DIM=1)
+      IF (ARRAY(A)/='') JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)
+   ENDDO
+   IF (ARRAY(1)/='') THEN
+      JOIN%RAW = ARRAY(1)//JOIN%RAW
+   ELSE
+      JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW))
+   ENDIF
+   ENDFUNCTION JOIN_CHARACTERS
+
+   PURE FUNCTION STRJOIN_STRINGS(ARRAY, SEP) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF STRINGS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)     :: STRINGS(3)
+   !< LOGICAL          :: TEST_PASSED(5)
+   !< STRINGS(1) = 'ONE'
+   !< STRINGS(2) = 'TWO'
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(1) = (STRJOIN(ARRAY=STRINGS)//''==STRINGS(1)//STRINGS(2)//STRINGS(3))
+   !< TEST_PASSED(2) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2)//'-'//STRINGS(3))
+   !< CALL STRINGS(1)%FREE
+   !< STRINGS(2) = 'TWO'
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(3) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(2)//'-'//STRINGS(3))
+   !< STRINGS(1) = 'ONE'
+   !< STRINGS(2) = 'TWO'
+   !< CALL STRINGS(3)%FREE
+   !< TEST_PASSED(4) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(2))
+   !< STRINGS(1) = 'ONE'
+   !< CALL STRINGS(2)%FREE
+   !< STRINGS(3) = 'THREE'
+   !< TEST_PASSED(5) = (STRJOIN(ARRAY=STRINGS, SEP='-')//''==STRINGS(1)//'-'//STRINGS(3))
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: ARRAY(1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: JOIN      !< THE JOIN OF ARRAY.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: A         !< COUNTER.
+
+   SEP_ = ''
+   IF (PRESENT(SEP)) SEP_ = SEP
+   JOIN = ''
+   DO A=2, SIZE(ARRAY, DIM=1)
+      IF (ALLOCATED(ARRAY(A)%RAW))JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)%RAW
+   ENDDO
+   IF (ALLOCATED(ARRAY(1)%RAW)) THEN
+      JOIN%RAW = ARRAY(1)%RAW//JOIN%RAW
+   ELSE
+      JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW))
+   ENDIF
+   ENDFUNCTION STRJOIN_STRINGS
+
+  PURE FUNCTION STRJOIN_CHARACTERS(ARRAY, SEP, IS_TRIM) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF AN ARRAY OF CHARACTERS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED.
+   !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE.
+   !<
+   !<```FORTRAN
+   !< CHARACTER(5) :: CHARACTERS(3)
+   !< LOGICAL      :: TEST_PASSED(13)
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(1) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3)))
+   !< TEST_PASSED(2) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3)))
+   !< TEST_PASSED(3) = ( STRJOIN(ARRAY=CHARACTERS, IS_TRIM=.FALSE.)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3))
+   !< TEST_PASSED(4) = ( STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3))
+   !< CHARACTERS(1) = ''
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(5) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3)))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = ''
+   !< TEST_PASSED(6) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2)))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = ''
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(7) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(3)))
+   !< CHARACTERS(1) = ''
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(8) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3)))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = ''
+   !< TEST_PASSED(9) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2)))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = ''
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(10) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(3)))
+   !< CHARACTERS(1) = ''
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(11) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(2)//'-'//CHARACTERS(3))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = 'TWO'
+   !< CHARACTERS(3) = ''
+   !< TEST_PASSED(12) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2))
+   !< CHARACTERS(1) = 'ONE'
+   !< CHARACTERS(2) = ''
+   !< CHARACTERS(3) = 'THREE'
+   !< TEST_PASSED(13) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(3))
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: ARRAY(1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: IS_TRIM   !< FLAG TO SETUP TRIM CHARACTER OR NOT
+   TYPE(STRING)                                    :: JOIN      !< THE JOIN OF ARRAY.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   LOGICAL                                         :: IS_TRIM_  !< FLAG TO SETUP TRIM CHARACTER OR NOT
+   INTEGER                                         :: A         !< COUNTER.
+
+   SEP_ = ''
+   IF (PRESENT(SEP)) SEP_ = SEP
+   IS_TRIM_ = .TRUE. ; IF (PRESENT(IS_TRIM)) IS_TRIM_ = IS_TRIM
+   JOIN = ''
+
+   IF (IS_TRIM_) THEN
+       DO A=2, SIZE(ARRAY, DIM=1)
+          IF (TRIM(ARRAY(A))/='') JOIN%RAW = JOIN%RAW//SEP_//TRIM(ARRAY(A))
+       ENDDO
+       IF (TRIM(ARRAY(1))/='') THEN
+          JOIN%RAW = TRIM(ARRAY(1))//JOIN%RAW
+       ELSE
+          JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW))
+       ENDIF
+   ELSE
+       DO A=2, SIZE(ARRAY, DIM=1)
+          IF (ARRAY(A)/='') JOIN%RAW = JOIN%RAW//SEP_//ARRAY(A)
+       ENDDO
+       IF (ARRAY(1)/='') THEN
+          JOIN%RAW = ARRAY(1)//JOIN%RAW
+       ELSE
+          JOIN%RAW = JOIN%RAW(LEN(SEP_)+1:LEN(JOIN%RAW))
+       ENDIF
+   ENDIF
+   ENDFUNCTION STRJOIN_CHARACTERS
+
+   PURE FUNCTION STRJOIN_STRINGS_ARRAY(ARRAY, SEP, IS_COL) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF COLUMNS OR ROWS OF AN ARRAY OF STRINGS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED.
+   !< THE IS_COL IS SETUP THE DIRECTION OF JOIN: WITHIN DEFAULT COLUMNS (.TRUE.) OR ROWS(.FALSE.).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS_ARR(:, :)
+   !< LOGICAL                   :: TEST_PASSED(5)
+   !<
+   !< STRINGS_ARR = RESHAPE( SOURCE = &
+   !<                        [STRING('ONE'), STRING('TWO'), STRING('THREE'),  &
+   !<                         STRING('ONE'), STRING('TWO'), STRING('THREE')], &
+   !<                        SHAPE = [3, 2] )
+   !<
+   !< TEST_PASSED(1) = ALL( STRJOIN(ARRAY=STRINGS_ARR) == &
+   !<                       RESHAPE([STRING('ONETWOTHREE'), STRING('ONETWOTHREE')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !< TEST_PASSED(2) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_') == &
+   !<                       RESHAPE([STRING('ONE_TWO_THREE'), STRING('ONE_TWO_THREE')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !<  TEST_PASSED(3) = ALL( STRJOIN(ARRAY=STRINGS_ARR, IS_COL=.FALSE.) == &
+   !<                        RESHAPE([STRING('ONEONE'), STRING('TWOTWO'), STRING('THREETHREE')], &
+   !<                        SHAPE = [3]) )
+   !<
+   !<  TEST_PASSED(4) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_', IS_COL=.FALSE.) == &
+   !<                        RESHAPE([STRING('ONE_ONE'), STRING('TWO_TWO'), STRING('THREE_THREE')], &
+   !<                        SHAPE = [3]) )
+   !<
+   !< CALL STRINGS_ARR(2, 1)%FREE
+   !< TEST_PASSED(5) = ALL( STRJOIN(ARRAY=STRINGS_ARR, SEP='_', IS_COL=.FALSE.) == &
+   !<                  RESHAPE([STRING('ONE_ONE'), STRING('TWO'), STRING('THREE_THREE')], &
+   !<                  SHAPE = [3]) )
+   !<
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: ARRAY(1:, 1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP  !< SEPARATOR.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: IS_COL  !< DIRECTION: 'COLUMNS' IF .TRUE. OR 'ROWS' IF .FALSE.
+   TYPE(STRING),              ALLOCATABLE          :: JOIN(:)       !< THE JOIN OF ARRAY.
+   TYPE(STRING),              ALLOCATABLE          :: SLICE(:)      !< THE COLUMN OR ROW SLICE OF ARRAY
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_          !< SEPARATOR, DEFAULT VALUE.
+   LOGICAL                                         :: IS_COL_       !< DIRECTION, DEFAULT VALUE.
+   INTEGER                                         :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
+
+   SEP_    = ''     ; IF (PRESENT(SEP)) SEP_ = SEP
+   IS_COL_ = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL
+
+   IF (IS_COL_) THEN
+       JOIN_SIZE  = SIZE(ARRAY, DIM=2)
+       SLICE_SIZE = SIZE(ARRAY, DIM=1)
+
+       IF (.NOT.ALLOCATED(JOIN))  ALLOCATE(JOIN(JOIN_SIZE))
+       IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(SLICE(SLICE_SIZE))
+       DO A = 1, JOIN_SIZE
+           SLICE(:) = ARRAY(:, A)
+           JOIN(A)  = STRJOIN_STRINGS(SLICE, SEP_)
+       END DO
+   ELSE
+       JOIN_SIZE  = SIZE(ARRAY, DIM=1)
+       SLICE_SIZE = SIZE(ARRAY, DIM=2)
+
+       IF (.NOT.ALLOCATED(JOIN))  ALLOCATE(JOIN(JOIN_SIZE))
+       IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(SLICE(SLICE_SIZE))
+       DO A = 1, JOIN_SIZE
+           SLICE(:) = ARRAY(A, :)
+           JOIN(A)  = STRJOIN_STRINGS(SLICE, SEP_)
+       END DO
+   ENDIF
+   ENDFUNCTION STRJOIN_STRINGS_ARRAY
+
+  PURE FUNCTION STRJOIN_CHARACTERS_ARRAY(ARRAY, SEP, IS_TRIM, IS_COL) RESULT(JOIN)
+   !< RETURN A STRING THAT IS A JOIN OF COLUMNS OR ROWS OF AN ARRAY OF CHARACTERS.
+   !<
+   !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED.
+   !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE.
+   !< THE IS_COL IS SETUP THE DIRECTION OF JOIN: WITHIN DEFAULT COLUMNS (.TRUE.) OR ROWS(.FALSE.).
+   !<
+   !<```FORTRAN
+   !< CHARACTER(LEN=10)         :: CHARS_ARR(3, 2)
+   !< LOGICAL                   :: TEST_PASSED(9)
+   !< CHARS_ARR(:, 1) = ['ONE       ', 'TWO       ', 'THREE     ']
+   !< CHARS_ARR(:, 2) = ['ONE       ', 'TWO       ', 'THREE     ']
+   !<
+   !< TEST_PASSED(1) = ALL( STRJOIN(ARRAY=CHARS_ARR) == &
+   !<                       RESHAPE([STRING('ONETWOTHREE'), STRING('ONETWOTHREE')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !< TEST_PASSED(2) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_TRIM=.FALSE.) ==  &
+   !<                       RESHAPE([STRING('ONE       TWO       THREE     '),  &
+   !<                                STRING('ONE       TWO       THREE     ')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !< TEST_PASSED(3) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_') == &
+   !<                       RESHAPE([STRING('ONE_TWO_THREE'), STRING('ONE_TWO_THREE')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !< TEST_PASSED(4) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_TRIM=.FALSE.) ==  &
+   !<                       RESHAPE([STRING('ONE       _TWO       _THREE     '),  &
+   !<                                STRING('ONE       _TWO       _THREE     ')], &
+   !<                       SHAPE = [2]) )
+   !<
+   !< TEST_PASSED(5) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_COL=.FALSE.) == &
+   !<                       RESHAPE([STRING('ONEONE'), STRING('TWOTWO'), STRING('THREETHREE')], &
+   !<                       SHAPE = [3]) )
+   !<
+   !< TEST_PASSED(6) = ALL( STRJOIN(ARRAY=CHARS_ARR, IS_TRIM=.FALSE., IS_COL=.FALSE.) ==  &
+   !<                       RESHAPE([STRING('ONE       ONE       '),  &
+   !<                                STRING('TWO       TWO       '),  &
+   !<                                STRING('THREE     THREE     ')], &
+   !<                       SHAPE = [3]) )
+   !<
+   !< TEST_PASSED(7) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_COL=.FALSE.) == &
+   !<                       RESHAPE([STRING('ONE_ONE'), STRING('TWO_TWO'), STRING('THREE_THREE')], &
+   !<                       SHAPE = [3]) )
+   !<
+   !< TEST_PASSED(8) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_TRIM=.FALSE., IS_COL=.FALSE.) ==  &
+   !<                       RESHAPE([STRING('ONE       _ONE       '),  &
+   !<                                STRING('TWO       _TWO       '),  &
+   !<                                STRING('THREE     _THREE     ')], &
+   !<                       SHAPE = [3]) )
+   !<
+   !< CHARS_ARR(2,1) = ''
+   !< TEST_PASSED(9) = ALL( STRJOIN(ARRAY=CHARS_ARR, SEP='_', IS_COL=.FALSE.) ==  &
+   !<                       RESHAPE([STRING('ONE_ONE'),  &
+   !<                                STRING('TWO'),  &
+   !<                                STRING('THREE_THREE')], &
+   !<                       SHAPE = [3]) )
+   !<
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: ARRAY(1:, 1:) !< ARRAY TO BE JOINED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: IS_TRIM   !< FLAG TO SETUP TRIM CHARACTER OR NOT
+   LOGICAL,                   INTENT(IN), OPTIONAL :: IS_COL    !< DIRECTION: 'COLUMNS' IF .TRUE. OR 'ROWS' IF .FALSE.
+   TYPE(STRING),              ALLOCATABLE          :: JOIN(:)   !< THE JOIN OF ARRAY.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SLICE(:)  !< THE COLUMN OR ROW SLICE OF ARRAY
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   LOGICAL                                         :: IS_TRIM_  !< FLAG TO SETUP TRIM CHARACTER OR NOT
+   LOGICAL                                         :: IS_COL_   !< DIRECTION, DEFAULT VALUE.
+   INTEGER                                         :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
+   INTEGER                                         :: ITEM_LEN  !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS)
+
+   ITEM_LEN = LEN(ARRAY(1,1)) !< ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS
+   SEP_     = ''     ; IF (PRESENT(SEP)) SEP_ = SEP
+   IS_TRIM_ = .TRUE. ; IF (PRESENT(IS_TRIM)) IS_TRIM_ = IS_TRIM
+   IS_COL_  = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL
+
+   IF (IS_COL_) THEN
+       JOIN_SIZE  = SIZE(ARRAY, DIM=2)
+       SLICE_SIZE = SIZE(ARRAY, DIM=1)
+
+       IF (.NOT.ALLOCATED(JOIN))  ALLOCATE(JOIN(JOIN_SIZE))
+       IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(CHARACTER(LEN=ITEM_LEN) :: SLICE(SLICE_SIZE))
+       DO A = 1, JOIN_SIZE
+           SLICE(:) = ARRAY(:, A)
+           JOIN(A)  = STRJOIN_CHARACTERS(SLICE, SEP_, IS_TRIM_)
+       END DO
+   ELSE
+       JOIN_SIZE  = SIZE(ARRAY, DIM=1)
+       SLICE_SIZE = SIZE(ARRAY, DIM=2)
+
+       IF (.NOT.ALLOCATED(JOIN))  ALLOCATE(JOIN(JOIN_SIZE))
+       IF (.NOT.ALLOCATED(SLICE)) ALLOCATE(CHARACTER(LEN=ITEM_LEN) :: SLICE(SLICE_SIZE))
+       DO A = 1, JOIN_SIZE
+           SLICE(:) = ARRAY(A, :)
+           JOIN(A)  = STRJOIN_CHARACTERS(SLICE, SEP_, IS_TRIM_)
+       END DO
+   ENDIF
+   ENDFUNCTION STRJOIN_CHARACTERS_ARRAY
+
+   ELEMENTAL FUNCTION LOWER(SELF)
+   !< RETURN A STRING WITH ALL LOWERCASE CHARACTERS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO WORLD!'
+   !< TEST_PASSED(1) = ASTRING%LOWER()//''=='HELLO WORLD!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF  !< THE STRING.
+   TYPE(STRING)              :: LOWER !< UPPER CASE STRING.
+   INTEGER                   :: N1    !< CHARACTERS COUNTER.
+   INTEGER                   :: N2    !< CHARACTERS COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      LOWER = SELF
+      DO N1=1, LEN(SELF%RAW)
+         N2 = INDEX(UPPER_ALPHABET, SELF%RAW(N1:N1))
+         IF (N2>0) LOWER%RAW(N1:N1) = LOWER_ALPHABET(N2:N2)
+      ENDDO
+   ENDIF
+   ENDFUNCTION LOWER
+
+   PURE FUNCTION PARTITION(SELF, SEP) RESULT(PARTITIONS)
+   !< SPLIT STRING AT SEPARATOR AND RETURN THE 3 PARTS (BEFORE, THE SEPARATOR AND AFTER).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: STRINGS(3)
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = 'HELLO WORLD!'
+   !< STRINGS = ASTRING%PARTITION(SEP='LO WO')
+   !< TEST_PASSED(1) = (STRINGS(1)//''=='HEL'.AND.STRINGS(2)//''=='LO WO'.AND.STRINGS(3)//''=='RLD!')
+   !< STRINGS = ASTRING%PARTITION(SEP='HELLO')
+   !< TEST_PASSED(2) = (STRINGS(1)//''==''.AND.STRINGS(2)//''=='HELLO'.AND.STRINGS(3)//''==' WORLD!')
+   !< ASTRING = 'HELLO WORLD!'
+   !< STRINGS = ASTRING%PARTITION()
+   !< TEST_PASSED(3) = (STRINGS(1)//''=='HELLO'.AND.STRINGS(2)//''==' '.AND.STRINGS(3)//''=='WORLD!')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF            !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP             !< SEPARATOR.
+   TYPE(STRING)                                    :: PARTITIONS(1:3) !< PARTIONS: BEFORE THE SEPARATOR, THE SEPARATOR ITSELS AND
+                                                                      !< AFTER THE SEPARATOR.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_            !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: C               !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP
+
+      PARTITIONS(1) = SELF
+      PARTITIONS(2) = SEP_
+      PARTITIONS(3) = ''
+      IF (LEN(SEP_)>=LEN(SELF%RAW)) RETURN
+      C = INDEX(SELF%RAW, SEP_)
+      IF (C>0) THEN
+         PARTITIONS(1)%RAW = SELF%RAW(1:C-1)
+         PARTITIONS(2)%RAW = SELF%RAW(C:C+LEN(SEP_)-1)
+         PARTITIONS(3)%RAW = SELF%RAW(C+LEN(SEP_):)
+      ENDIF
+   ENDIF
+   ENDFUNCTION PARTITION
+
+   SUBROUTINE READ_FILE(SELF, FILE, IS_FAST, FORM, IOSTAT, IOMSG)
+   !< READ A FILE AS A SINGLE STRING STREAM.
+   !<
+   !< @NOTE ALL THE LINES ARE STORED INTO THE STRING SELF AS A SINGLE ASCII STREAM. EACH LINE (RECORD) IS SEPARATED BY A `NEW_LINE`
+   !< CHARACTER.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !< @NOTE *FAST* FILE READING ALLOWS A VERY EFFICIENT READING OF STREAMED FILE, BUT IT DUMPS FILE AS SINGLE STREAMED STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< TYPE(STRING)              :: LINE(3)
+   !< INTEGER                   :: IOSTAT
+   !< CHARACTER(LEN=99)         :: IOMSG
+   !< INTEGER                   :: SCRATCH
+   !< INTEGER                   :: L
+   !< LOGICAL                   :: TEST_PASSED(9)
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP')
+   !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS()
+   !< CLOSE(SCRATCH)
+   !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+1) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A')
+   !< CLOSE(SCRATCH)
+   !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+5) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< CLOSE(SCRATCH, STATUS='DELETE')
+   !< CALL ASTRING%READ_FILE(FILE='READ_FILE_TEST.TMP', IOSTAT=IOSTAT)
+   !< TEST_PASSED(9) = (IOSTAT/=0)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(INOUT)           :: SELF       !< THE STRING.
+   CHARACTER(LEN=*), INTENT(IN)              :: FILE       !< FILE NAME.
+   LOGICAL,          INTENT(IN),    OPTIONAL :: IS_FAST    !< FLAG TO ENABLE (SUPER) FAST FILE READING.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM       !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT     !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG      !< IO STATUS MESSAGE.
+   LOGICAL                                   :: IS_FAST_   !< FLAG TO ENABLE (SUPER) FAST FILE READING, LOCAL VARIABLE.
+   TYPE(STRING)                              :: FORM_      !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                   :: IOSTAT_    !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE             :: IOMSG_     !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   INTEGER                                   :: UNIT       !< LOGICAL UNIT.
+   LOGICAL                                   :: DOES_EXIST !< CHECK IF FILE EXIST.
+   INTEGER(I4P)                              :: FILESIZE   !< SIZE OF THE FILE FOR FAST READING.
+
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   INQUIRE(FILE=FILE, IOMSG=IOMSG_, IOSTAT=IOSTAT_, EXIST=DOES_EXIST)
+   IF (DOES_EXIST) THEN
+      IS_FAST_ = .FALSE. ; IF (PRESENT(IS_FAST)) IS_FAST_ = IS_FAST
+      IF (IS_FAST_) THEN
+         OPEN(NEWUNIT=UNIT, FILE=FILE, ACCESS='STREAM', FORM='UNFORMATTED', IOMSG=IOMSG_, IOSTAT=IOSTAT_)
+         INQUIRE(FILE=FILE, SIZE=FILESIZE)
+         IF (ALLOCATED(SELF%RAW)) DEALLOCATE(SELF%RAW)
+         ALLOCATE(CHARACTER(LEN=FILESIZE):: SELF%RAW)
+         READ(UNIT=UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW
+         CLOSE(UNIT)
+      ELSE
+         FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+         SELECT CASE(FORM_%CHARS())
+         CASE('FORMATTED')
+            OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+         CASE('UNFORMATTED')
+            OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', FORM='UNFORMATTED', ACCESS='STREAM', &
+                 IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+         ENDSELECT
+         CALL SELF%READ_LINES(UNIT=UNIT, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_)
+         10 CLOSE(UNIT)
+      ENDIF
+   ELSE
+      IOSTAT_ = 1
+      IOMSG_ = 'FILE NOT FOUND'
+   ENDIF
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE READ_FILE
+
+   SUBROUTINE READ_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG)
+   !< READ LINE (RECORD) FROM A CONNECTED UNIT.
+   !<
+   !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)      :: ASTRING
+   !< TYPE(STRING)      :: LINE(3)
+   !< INTEGER           :: IOSTAT
+   !< CHARACTER(LEN=99) :: IOMSG
+   !< INTEGER           :: SCRATCH
+   !< INTEGER           :: L
+   !< LOGICAL           :: TEST_PASSED(6)
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH')
+   !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS()
+   !< REWIND(SCRATCH)
+   !< L = 0
+   !< IOSTAT = 0
+   !< DO
+   !<   L = L + 1
+   !<   CALL ASTRING%READ_LINE(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !<   IF (IOSTAT/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT)) THEN
+   !<     EXIT
+   !<   ELSE
+   !<     TEST_PASSED(L) = (ASTRING==LINE(L))
+   !<   ENDIF
+   !< ENDDO
+   !< CLOSE(SCRATCH)
+   !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A')
+   !< REWIND(SCRATCH)
+   !< L = 0
+   !< IOSTAT = 0
+   !< DO
+   !<   L = L + 1
+   !<   CALL ASTRING%READ_LINE(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG, FORM='UNFORMATTED')
+   !<   IF (IOSTAT/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT)) THEN
+   !<     EXIT
+   !<   ELSE
+   !<     TEST_PASSED(L+3) = (ASTRING==LINE(L))
+   !<   ENDIF
+   !< ENDDO
+   !< CLOSE(SCRATCH)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(INOUT)           :: SELF    !< THE STRING.
+   INTEGER,          INTENT(IN)              :: UNIT    !< LOGICAL UNIT.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM    !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT  !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG   !< IO STATUS MESSAGE.
+   TYPE(STRING)                              :: FORM_   !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                   :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:),          ALLOCATABLE    :: IOMSG_  !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE    :: LINE    !< LINE STORAGE.
+   CHARACTER(KIND=CK, LEN=1)                 :: CH      !< CHARACTER STORAGE.
+
+   FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   LINE = ''
+   SELECT CASE(FORM_%CHARS())
+   CASE('FORMATTED')
+      DO
+         READ(UNIT, "(A)", ADVANCE='NO', IOSTAT=IOSTAT_, IOMSG=IOMSG_, ERR=10, END=10, EOR=10) CH
+         LINE = LINE//CH
+      ENDDO
+   CASE('UNFORMATTED')
+      DO
+         READ(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_, ERR=10, END=10) CH
+         IF (CH==NEW_LINE('A')) THEN
+            IOSTAT_ = IOSTAT_EOR
+            EXIT
+         ENDIF
+         LINE = LINE//CH
+      ENDDO
+   ENDSELECT
+   10 IF (LINE/='') SELF%RAW = LINE
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE READ_LINE
+
+   SUBROUTINE READ_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG)
+   !< READ (ALL) LINES (RECORDS) FROM A CONNECTED UNIT AS A SINGLE ASCII STREAM.
+   !<
+   !< @NOTE ALL THE LINES ARE STORED INTO THE STRING SELF AS A SINGLE ASCII STREAM. EACH LINE (RECORD) IS SEPARATED BY A `NEW_LINE`
+   !< CHARACTER. THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED.
+   !<
+   !< @NOTE THE CONNECTED UNIT IS REWINDED. AT A SUCCESSFUL EXIT CURRENT RECORD IS AT EOF, AT THE BEGINNING OTHERWISE.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< TYPE(STRING)              :: LINE(3)
+   !< INTEGER                   :: IOSTAT
+   !< CHARACTER(LEN=99)         :: IOMSG
+   !< INTEGER                   :: SCRATCH
+   !< INTEGER                   :: L
+   !< LOGICAL                   :: TEST_PASSED(8)
+   !<
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH')
+   !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS()
+   !< CALL ASTRING%READ_LINES(UNIT=SCRATCH, IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+1) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< CLOSE(SCRATCH)
+   !< OPEN(NEWUNIT=SCRATCH, STATUS='SCRATCH', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A')
+   !< CALL ASTRING%READ_LINES(UNIT=SCRATCH, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+5) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< CLOSE(SCRATCH)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(INOUT)           :: SELF    !< THE STRING.
+   INTEGER,          INTENT(IN)              :: UNIT    !< LOGICAL UNIT.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM    !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT  !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG   !< IO STATUS MESSAGE.
+   INTEGER                                   :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE             :: IOMSG_  !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   TYPE(STRING)                              :: LINES   !< LINES STORAGE.
+   TYPE(STRING)                              :: LINE    !< LINE STORAGE.
+
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   REWIND(UNIT)
+   IOSTAT_ = 0
+   LINES%RAW = ''
+   DO
+      LINE%RAW = ''
+      CALL LINE%READ_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT_, IOMSG=IOMSG_)
+      IF (IOSTAT_/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT_)) THEN
+         EXIT
+      ELSEIF (LINE/='') THEN
+         LINES%RAW = LINES%RAW//LINE%RAW//NEW_LINE('A')
+      ENDIF
+   ENDDO
+   IF (LINES%RAW/='') SELF%RAW = LINES%RAW
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE READ_LINES
+
+   ELEMENTAL FUNCTION REPLACE(SELF, OLD, NEW, COUNT) RESULT(REPLACED)
+   !< RETURN A STRING WITH ALL OCCURRENCES OF SUBSTRING OLD REPLACED BY NEW.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = 'WHEN YOU ARE SAD YOU SHOULD THINK TO ME :-)'
+   !< TEST_PASSED(1) = (ASTRING%REPLACE(OLD='YOU', NEW='THEY')//''=='WHEN THEY ARE SAD THEY SHOULD THINK TO ME :-)')
+   !< TEST_PASSED(2) = (ASTRING%REPLACE(OLD='YOU', NEW='THEY', COUNT=1)//''=='WHEN THEY ARE SAD YOU SHOULD THINK TO ME :-)')
+   !< ASTRING = REPEAT(NEW_LINE('A')//'ABCD', 20)
+   !< ASTRING = ASTRING%REPLACE(OLD=NEW_LINE('A'), NEW='|CR|')
+   !< ASTRING = ASTRING%REPLACE(OLD='|CR|', NEW=NEW_LINE('A')//'    ')
+   !< TEST_PASSED(3) = (ASTRING//''==REPEAT(NEW_LINE('A')//'    '//'ABCD', 20))
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF     !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: OLD      !< OLD SUBSTRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: NEW      !< NEW SUBSTRING.
+   INTEGER,                   INTENT(IN), OPTIONAL :: COUNT    !< NUMBER OF OLD OCCURENCES TO BE REPLACED.
+   TYPE(STRING)                                    :: REPLACED !< THE STRING WITH OLD REPLACED BY NEW.
+   INTEGER                                         :: R        !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      REPLACED = SELF
+      R = 0
+      DO
+         IF (INDEX(REPLACED%RAW, OLD)>0) THEN
+            REPLACED = REPLACED%REPLACE_ONE_OCCURRENCE(OLD=OLD, NEW=NEW)
+            R = R + 1
+            IF (PRESENT(COUNT)) THEN
+               IF (R>=COUNT) EXIT
+            ENDIF
+         ELSE
+            EXIT
+         ENDIF
+      ENDDO
+   ENDIF
+   ENDFUNCTION REPLACE
+
+   ELEMENTAL FUNCTION REVERSE(SELF) RESULT(REVERSED)
+   !< RETURN A REVERSED STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = 'ABCDEFGHILMNOPQRSTUVZ'
+   !< TEST_PASSED(1) = (ASTRING%REVERSE()//''=='ZVUTSRQPONMLIHGFEDCBA')
+   !< ASTRING = '0123456789'
+   !< TEST_PASSED(2) = (ASTRING%REVERSE()//''=='9876543210')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   TYPE(STRING)              :: REVERSED !< THE REVERSED STRING.
+   INTEGER                   :: LENGTH   !< LENGTH OF THE STRING.
+   INTEGER                   :: C        !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      REVERSED = SELF
+      LENGTH = LEN(SELF%RAW)
+      DO C=1, LENGTH
+         REVERSED%RAW(C:C) = SELF%RAW(LENGTH-C+1:LENGTH-C+1)
+      ENDDO
+   ENDIF
+   ENDFUNCTION REVERSE
+
+   FUNCTION SEARCH(SELF, TAG_START, TAG_END, IN_STRING, IN_CHARACTER, ISTART, IEND) RESULT(TAG)
+   !< SEARCH FOR *TAGGED* RECORD INTO STRING, RETURN THE FIRST RECORD FOUND (IF ANY) MATCHING THE TAGS.
+   !<
+   !< OPTIONALLY, RETURNS THE INDEXES OF TAG START/END, THUS THIS IS NOT AN `ELEMENTAL` FUNCTION.
+   !<
+   !< @NOTE THE TAGGED RECORD IS SEARCHED INTO SELF IF ALLOCATED OTHERWISE INTO `IN_STRING` IF PASSED OR, EVENTUALLY, INTO
+   !< `IN_CHARACTER` IS PASSED. IF TAG IS NOT FOUND THE RETURN STRING IS NOT ALLOCATED AND THE START/END INDEXES (IF REQUESTED) ARE
+   !< ZERO.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< TYPE(STRING)                  :: ANOTHERSTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< INTEGER                       :: ISTART
+   !< INTEGER                       :: IEND
+   !< LOGICAL                       :: TEST_PASSED(5)
+   !< ASTRING = '<TEST> <FIRST> HELLO </FIRST> <FIRST> NOT THE FIRST </FIRST> </TEST>'
+   !< ANOTHERSTRING = ASTRING%SEARCH(TAG_START='<FIRST>', TAG_END='</FIRST>')
+   !< TEST_PASSED(1) = ANOTHERSTRING//''=='<FIRST> HELLO </FIRST>'
+   !< ASTRING = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>'
+   !< ANOTHERSTRING = ASTRING%SEARCH(TAG_START='<A>', TAG_END='</A>')
+   !< TEST_PASSED(2) = ANOTHERSTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>'
+   !< CALL ASTRING%FREE
+   !< ANOTHERSTRING = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>'
+   !< ASTRING = ASTRING%SEARCH(IN_STRING=ANOTHERSTRING, TAG_START='<A>', TAG_END='</A>')
+   !< TEST_PASSED(3) = ASTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>'
+   !< CALL ASTRING%FREE
+   !< ACHARACTER = '<TEST> <A> <A> <A> THE NESTED A </A> </A> </A> </TEST>'
+   !< ASTRING = ASTRING%SEARCH(IN_CHARACTER=ACHARACTER, TAG_START='<A>', TAG_END='</A>')
+   !< TEST_PASSED(4) = ASTRING//''=='<A> <A> <A> THE NESTED A </A> </A> </A>'
+   !< ACHARACTER = '<TEST> <FIRST> HELLO </FIRST> <SEC> <SEC>NOT THE FIRST</SEC> </SEC> </TEST>'
+   !< ASTRING = ASTRING%SEARCH(IN_CHARACTER=ACHARACTER, TAG_START='<SEC>', TAG_END='</SEC>', ISTART=ISTART, IEND=IEND)
+   !< TEST_PASSED(5) = ASTRING//''==ACHARACTER(31:67)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)            :: SELF         !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)            :: TAG_START    !< START TAG.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)            :: TAG_END      !< END TAG.
+   TYPE(STRING),              INTENT(IN),  OPTIONAL :: IN_STRING    !< SEARCH INTO THIS STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN),  OPTIONAL :: IN_CHARACTER !< SEARCH INTO THIS CHARACTER STRING.
+   INTEGER,                   INTENT(OUT), OPTIONAL :: ISTART       !< STARTING INDEX OF TAG INSIDE THE STRING.
+   INTEGER,                   INTENT(OUT), OPTIONAL :: IEND         !< ENDING INDEX OF TAG INSIDE THE STRING.
+   TYPE(STRING)                                     :: TAG          !< FIRST TAG FOUND.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE           :: RAW          !< RAW STRING INTO WHICH SEARCH THE TAG.
+   INTEGER                                          :: ISTART_      !< STARTING INDEX OF TAG INSIDE THE STRING, LOCAL VARIABLE.
+   INTEGER                                          :: IEND_        !< ENDING INDEX OF TAG INSIDE THE STRING, LOCAL VARIABLE.
+   INTEGER                                          :: NESTED_TAGS  !< NUMBER OF NESTED TAGS INSIDE TAG.
+   INTEGER                                          :: T            !< COUNTER.
+
+   RAW = ''
+   IF (PRESENT(IN_STRING)) THEN
+      RAW = IN_STRING%RAW
+   ELSEIF (PRESENT(IN_CHARACTER)) THEN
+      RAW = IN_CHARACTER
+   ELSE
+      IF (ALLOCATED(SELF%RAW)) RAW = SELF%RAW
+   ENDIF
+   ISTART_ = 0
+   IEND_ = 0
+   IF (RAW/='') THEN
+      ISTART_ = INDEX(RAW, TAG_START)
+      IEND_ = INDEX(RAW, TAG_END)
+      IF (ISTART_>0.AND.IEND_>0) THEN
+         IEND_ = IEND_ + LEN(TAG_END) - 1
+         TAG%RAW = RAW(ISTART_:IEND_)
+         NESTED_TAGS = TAG%COUNT(TAG_START)
+         IF (NESTED_TAGS>1) THEN
+            DO T=2, NESTED_TAGS
+               IEND_ = IEND_ + LEN(TAG_END) - 1 + INDEX(RAW(IEND_+1:), TAG_END)
+            ENDDO
+            TAG%RAW = RAW(ISTART_:IEND_)
+         ENDIF
+      ENDIF
+   ENDIF
+   IF (PRESENT(ISTART)) ISTART = ISTART_
+   IF (PRESENT(IEND)) IEND = IEND_
+   ENDFUNCTION SEARCH
+
+   PURE FUNCTION SLICE(SELF, ISTART, IEND) RESULT(RAW)
+   !< RETURN THE RAW CHARACTERS DATA SLICED.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+   !< PRINT "(A)", ASTRING%SLICE(11,25)
+   !<```
+   !=> BROWN FOX JUMPS <<<
+   CLASS(STRING), INTENT(IN)              :: SELF   !< THE STRING.
+   INTEGER,       INTENT(IN)              :: ISTART !< SLICE START INDEX.
+   INTEGER,       INTENT(IN)              :: IEND   !< SLICE END   INDEX.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: RAW    !< RAW CHARACTERS DATA.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      RAW = SELF%RAW(ISTART:IEND)
+   ELSE
+      RAW = ''
+   ENDIF
+   ENDFUNCTION SLICE
+
+   ELEMENTAL FUNCTION SNAKECASE(SELF, SEP)
+   !< RETURN A STRING WITH ALL WORDS LOWERCASE SEPARATED BY "_".
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+   !< TEST_PASSED(1) = ASTRING%SNAKECASE()//''=='THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG.'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: SNAKECASE !< SNAKE CASE STRING.
+   TYPE(STRING), ALLOCATABLE                       :: TOKENS(:) !< STRING TOKENS.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP)
+      TOKENS = TOKENS%LOWER()
+      SNAKECASE = SNAKECASE%JOIN(ARRAY=TOKENS, SEP='_')
+   ENDIF
+   ENDFUNCTION SNAKECASE
+
+   PURE SUBROUTINE SPLIT(SELF, TOKENS, SEP, MAX_TOKENS)
+   !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING.
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURRENCE.
+   !<
+   !< @NOTE IF `MAX_TOKENS` IS PASSED THE RETURNED NUMBER OF TOKENS IS EITHER `MAX_TOKENS` OR `MAX_TOKENS + 1`.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< LOGICAL                   :: TEST_PASSED(11)
+   !< ASTRING = '+AB-++CRE-++CRE-AB+'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(1) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB')
+   !< ASTRING = 'AB-++CRE-++CRE-AB+'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(2) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB')
+   !< ASTRING = 'AB-++CRE-++CRE-AB'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(3) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CRE-'.AND.STRINGS(3)//''=='CRE-AB')
+   !< ASTRING = 'HELLO '//NEW_LINE('A')//'WORLD!'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(4) = (STRINGS(1)//''=='HELLO '.AND.STRINGS(2)//''=='WORLD!')
+   !< ASTRING = 'HELLO WORLD!'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS)
+   !< TEST_PASSED(5) = (STRINGS(1)//''=='HELLO'.AND.STRINGS(2)//''=='WORLD!')
+   !< ASTRING = '+AB-'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(6) = (STRINGS(1)//''=='AB-')
+   !< ASTRING = '+AB-'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='-')
+   !< TEST_PASSED(7) = (STRINGS(1)//''=='+AB')
+   !< ASTRING = '+AB-+CD-'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(8) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-')
+   !< ASTRING = 'AB-+CD-+'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(9) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-')
+   !< ASTRING = '+AB-+CD-+'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='+')
+   !< TEST_PASSED(10) = (STRINGS(1)//''=='AB-'.AND.STRINGS(2)//''=='CD-')
+   !< ASTRING = '1-2-3-4-5-6-7-8'
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP='-', MAX_TOKENS=3)
+   !< TEST_PASSED(11) = (STRINGS(1)//''=='1'.AND.STRINGS(2)//''=='2'.AND.STRINGS(3)//''=='3'.AND.STRINGS(4)//''=='4-5-6-7-8')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF           !< THE STRING.
+   TYPE(STRING), ALLOCATABLE, INTENT(OUT)          :: TOKENS(:)      !< TOKENS SUBSTRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP            !< SEPARATOR.
+   INTEGER,                   INTENT(IN), OPTIONAL :: MAX_TOKENS     !< FIX THE MAXIMUM NUMBER OF RETURNED TOKENS.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_           !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: NO             !< NUMBER OF OCCURRENCES OF SEP.
+   INTEGER                                         :: T              !< CHARACTER COUNTER.
+   TYPE(STRING)                                    :: TEMPORARY      !< TEMPORARY STORAGE.
+   TYPE(STRING), ALLOCATABLE                       :: TEMP_TOKS(:,:) !< TEMPORARY TOKENS SUBSTRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP
+
+     TEMPORARY = SELF%UNIQUE(SEP_)
+     NO = TEMPORARY%COUNT(SEP_)
+
+     IF (NO>0) THEN
+       IF (PRESENT(MAX_TOKENS)) THEN
+         IF (MAX_TOKENS < NO.AND.MAX_TOKENS > 0) NO = MAX_TOKENS
+       ENDIF
+       ALLOCATE(TEMP_TOKS(3, NO))
+       TEMP_TOKS(:, 1) = TEMPORARY%PARTITION(SEP_)
+       IF (NO>1) THEN
+         DO T=2, NO
+           TEMP_TOKS(:, T) = TEMP_TOKS(3, T-1)%PARTITION(SEP_)
+         ENDDO
+       ENDIF
+
+       IF (TEMP_TOKS(1, 1)%RAW/=''.AND.TEMP_TOKS(3, NO)%RAW/='') THEN
+         ALLOCATE(TOKENS(NO+1))
+         DO T=1, NO
+           IF (T==NO) THEN
+             TOKENS(T  ) = TEMP_TOKS(1, T)
+             TOKENS(T+1) = TEMP_TOKS(3, T)
+           ELSE
+             TOKENS(T) = TEMP_TOKS(1, T)
+           ENDIF
+         ENDDO
+       ELSEIF (TEMP_TOKS(1, 1)%RAW/='') THEN
+         ALLOCATE(TOKENS(NO))
+         DO T=1, NO
+           TOKENS(T) = TEMP_TOKS(1, T)
+         ENDDO
+       ELSEIF (TEMP_TOKS(3, NO)%RAW/='') THEN
+         ALLOCATE(TOKENS(NO))
+         DO T=1, NO-1
+           TOKENS(T) = TEMP_TOKS(1, T+1)
+         ENDDO
+         TOKENS(NO) = TEMP_TOKS(3, NO)
+       ELSE
+         ALLOCATE(TOKENS(NO-1))
+         DO T=2, NO
+           TOKENS(T-1) = TEMP_TOKS(1, T)
+         ENDDO
+       ENDIF
+
+     ELSE
+       ALLOCATE(TOKENS(1))
+       TOKENS(1) = SELF
+     ENDIF
+   ENDIF
+   ENDSUBROUTINE SPLIT
+
+   PURE SUBROUTINE SPLIT_CHUNKED(SELF, TOKENS, CHUNKS, SEP)
+   !< RETURN A LIST OF SUBSTRING IN THE STRING, USING SEP AS THE DELIMITER STRING, CHUNKED (MEMORY-EFFICIENT) ALGORITHM.
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURRENCE.
+   !<
+   !< @NOTE THE SPLIT IS PERFORMED IN CHUNKS OF `#CHUNKS` TO AVOID EXCESSIVE MEMORY CONSUMPTION.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< LOGICAL                   :: TEST_PASSED(1)
+   !< ASTRING = '-1-2-3-4-5-6-7-8-'
+   !< CALL ASTRING%SPLIT_CHUNKED(TOKENS=STRINGS, SEP='-', CHUNKS=3)
+   !< TEST_PASSED(1) = (STRINGS(1)//''=='1'.AND.STRINGS(2)//''=='2'.AND.STRINGS(3)//''=='3'.AND.STRINGS(4)//''=='4'.AND. &
+   !<                   STRINGS(5)//''=='5'.AND.STRINGS(6)//''=='6'.AND.STRINGS(7)//''=='7'.AND.STRINGS(8)//''=='8')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   TYPE(STRING), ALLOCATABLE, INTENT(OUT)          :: TOKENS(:) !< TOKENS SUBSTRING.
+   INTEGER,                   INTENT(IN)           :: CHUNKS    !< NUMBER OF CHUNKS.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   INTEGER                                         :: NT        !< NUMBER OF ACTUAL TOKENS.
+   INTEGER                                         :: T         !< COUNTER.
+   LOGICAL                                         :: ISOK
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP
+
+     NT = SELF%COUNT(SEP_)
+     IF (SELF%START_WITH(PREFIX=SEP_)) NT = NT - 1
+     IF (SELF%END_WITH(SUFFIX=SEP_)) NT = NT - 1
+     T = 0
+     CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP_, MAX_TOKENS=CHUNKS)
+     DO
+       T = SIZE(TOKENS, DIM=1)
+       IF (T > NT) EXIT
+       CALL SPLIT_LAST_TOKEN(TOKENS=TOKENS, MAX_TOKENS=CHUNKS,ISOK=ISOK)
+       IF(ISOK)THEN
+       ELSE
+            EXIT
+       ENDIF
+     ENDDO
+
+     T = SIZE(TOKENS, DIM=1)
+     IF (TOKENS(T)%COUNT(SEP_) > 0) THEN
+        CALL SPLIT_LAST_TOKEN(TOKENS=TOKENS,ISOK=ISOK)
+     ENDIF
+   ENDIF
+
+   CONTAINS
+      PURE SUBROUTINE SPLIT_LAST_TOKEN(TOKENS, MAX_TOKENS,ISOK)
+      !< SPLIT LAST TOKEN.
+      TYPE(STRING), ALLOCATABLE, INTENT(INOUT)        :: TOKENS(:)      !< TOKENS SUBSTRING.
+      INTEGER,                   INTENT(IN), OPTIONAL :: MAX_TOKENS     !< MAX TOKENS RETURNED.
+      TYPE(STRING), ALLOCATABLE                       :: TOKENS_(:)     !< TEMPORARY TOKENS.
+      TYPE(STRING), ALLOCATABLE                       :: TOKENS_SWAP(:) !< SWAP TOKENS.
+      INTEGER                                         :: NT_            !< NUMBER OF LAST CREATED TOKENS.
+      LOGICAL,INTENT(OUT)                             :: ISOK
+
+      ISOK=.TRUE.
+      CALL TOKENS(T)%SPLIT(TOKENS=TOKENS_, SEP=SEP_, MAX_TOKENS=MAX_TOKENS)
+      IF (ALLOCATED(TOKENS_)) THEN
+        NT_ = SIZE(TOKENS_, DIM=1)
+        IF (NT_ >= 1) THEN
+          ALLOCATE(TOKENS_SWAP(1:T-1+NT_))
+          TOKENS_SWAP(1:T-1) = TOKENS(1:T-1)
+          TOKENS_SWAP(T:)    = TOKENS_(:)
+          CALL MOVE_ALLOC(FROM=TOKENS_SWAP, TO=TOKENS)
+        ENDIF
+        IF (NT_ == 1) THEN
+            ISOK=.FALSE.
+        END IF
+        DEALLOCATE(TOKENS_)
+      ENDIF
+      ENDSUBROUTINE SPLIT_LAST_TOKEN
+   ENDSUBROUTINE SPLIT_CHUNKED
+
+   ELEMENTAL FUNCTION STARTCASE(SELF, SEP)
+   !< RETURN A STRING WITH ALL WORDS CAPITALIZED, E.G. TITLE CASE.
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+   !< TEST_PASSED(1) = ASTRING%STARTCASE()//''=='THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG.'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
+   TYPE(STRING)                                    :: STARTCASE !< START CASE STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
+   TYPE(STRING), ALLOCATABLE                       :: TOKENS(:) !< STRING TOKENS.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SEP_ = SPACE ; IF (PRESENT(SEP)) SEP_ = SEP
+      CALL SELF%SPLIT(TOKENS=TOKENS, SEP=SEP_)
+      TOKENS = TOKENS%CAPITALIZE()
+      STARTCASE = STARTCASE%JOIN(ARRAY=TOKENS, SEP=SEP_)
+   ENDIF
+   ENDFUNCTION STARTCASE
+
+   ELEMENTAL FUNCTION STRIP(SELF, REMOVE_NULLS)
+   !< RETURN A COPY OF THE STRING WITH THE LEADING AND TRAILING CHARACTERS REMOVED.
+   !<
+   !< @NOTE MULTIPLE SUBSEQUENT SEPARATORS ARE COLLAPSED TO ONE OCCURENCE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '  HELLO WORLD!   '
+   !< TEST_PASSED(1) = ASTRING%STRIP()//''=='HELLO WORLD!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF         !< THE STRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: REMOVE_NULLS !< REMOVE NULL CHARACTERS AT THE END.
+   TYPE(STRING)                        :: STRIP        !< THE STRIPPED STRING.
+   INTEGER                             :: C            !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      STRIP = SELF%ADJUSTL()
+      STRIP = STRIP%TRIM()
+      IF (PRESENT(REMOVE_NULLS)) THEN
+         IF (REMOVE_NULLS) THEN
+            C = INDEX(SELF%RAW, CHAR(0))
+            IF (C>0) STRIP%RAW = STRIP%RAW(1:C-1)
+         ENDIF
+      ENDIF
+   ENDIF
+   ENDFUNCTION STRIP
+
+   ELEMENTAL FUNCTION SWAPCASE(SELF)
+   !< RETURN A COPY OF THE STRING WITH UPPERCASE CHARACTERS CONVERTED TO LOWERCASE AND VICE VERSA.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '  HELLO WORLD!   '
+   !< TEST_PASSED(1) = ASTRING%SWAPCASE()//''=='  HELLO WORLD!   '
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   TYPE(STRING)              :: SWAPCASE !< UPPER CASE STRING.
+   INTEGER                   :: N1       !< CHARACTERS COUNTER.
+   INTEGER                   :: N2       !< CHARACTERS COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      SWAPCASE = SELF
+      DO N1=1, LEN(SELF%RAW)
+         N2 = INDEX(UPPER_ALPHABET, SELF%RAW(N1:N1))
+         IF (N2>0) THEN
+            SWAPCASE%RAW(N1:N1) = LOWER_ALPHABET(N2:N2)
+         ELSE
+            N2 = INDEX(LOWER_ALPHABET, SELF%RAW(N1:N1))
+            IF (N2>0) SWAPCASE%RAW(N1:N1) = UPPER_ALPHABET(N2:N2)
+         ENDIF
+      ENDDO
+   ENDIF
+   ENDFUNCTION SWAPCASE
+
+   FUNCTION TEMPNAME(SELF, IS_FILE, PREFIX, PATH)
+   !< RETURN A SAFE TEMPORARY NAME SUITABLE FOR TEMPORARY FILE OR DIRECTORIES.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: TMPNAME
+   !< LOGICAL                       :: TEST_PASSED(5)
+   !< TMPNAME = ASTRING%TEMPNAME()
+   !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(1))
+   !< TEST_PASSED(1) = .NOT.TEST_PASSED(1)
+   !< TMPNAME = ASTRING%TEMPNAME(IS_FILE=.FALSE.)
+   !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(2))
+   !< TEST_PASSED(2) = .NOT.TEST_PASSED(2)
+   !< TMPNAME = ASTRING%TEMPNAME(PATH='./')
+   !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(3))
+   !< TEST_PASSED(3) = .NOT.TEST_PASSED(3)
+   !< ASTRING = 'ME-'
+   !< TMPNAME = ASTRING%TEMPNAME()
+   !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(4))
+   !< TEST_PASSED(4) = .NOT.TEST_PASSED(4)
+   !< TMPNAME = ASTRING%TEMPNAME(PREFIX='YOU-')
+   !< INQUIRE(FILE=TMPNAME, EXIST=TEST_PASSED(5))
+   !< TEST_PASSED(5) = .NOT.TEST_PASSED(5)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF                   !< THE STRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: IS_FILE                !< TRUE IF TEMPNAME SHOULD BE USED FOR FILE (THE DEFAULT).
+   CHARACTER(*),  INTENT(IN), OPTIONAL :: PREFIX                 !< NAME PREFIX, OTHERWISE SELF IS USED (IF ALLOCATED).
+   CHARACTER(*),  INTENT(IN), OPTIONAL :: PATH                   !< PATH WHERE FILE/DIRECTORY SHOULD BE USED, DEFAULT `./`.
+   CHARACTER(LEN=:), ALLOCATABLE       :: TEMPNAME               !< SAFE (UNIQUE) TEMPORARY NAME.
+   LOGICAL                             :: IS_FILE_               !< TRUE IF TEMPNAME SHOULD BE USED FOR FILE (THE DEFAULT).
+   CHARACTER(LEN=:), ALLOCATABLE       :: PREFIX_                !< NAME PREFIX, OTHERWISE SELF IS USED (IF ALLOCATED).
+   CHARACTER(LEN=:), ALLOCATABLE       :: PATH_                  !< PATH WHERE FILE/DIRECTORY SHOULD BE USED, DEFAULT `./`.
+   LOGICAL, SAVE                       :: IS_INITIALIZED=.FALSE. !< STATUS OF RANDOM SEED INITIALIZATION.
+   REAL(R4P)                           :: RANDOM_REAL            !< RANDOM NUMBER (REAL).
+   INTEGER(I4P)                        :: RANDOM_INTEGER         !< RANDOM NUMBER (INTEGER).
+   LOGICAL                             :: IS_HOLD                !< FLAG TO CHECK IF A SAFE TEMPNAME HAS BEEN FOUND.
+
+   IS_FILE_ = .TRUE. ; IF (PRESENT(IS_FILE)) IS_FILE_ = IS_FILE
+   PATH_ = '' ; IF (PRESENT(PATH)) PATH_ = PATH
+   PREFIX_ = ''
+   IF (PRESENT(PREFIX)) THEN
+      PREFIX_ = PREFIX
+   ELSEIF (ALLOCATED(SELF%RAW)) THEN
+      PREFIX_ = SELF%RAW
+   ENDIF
+   IF (.NOT.IS_INITIALIZED) THEN
+      CALL RANDOM_SEED
+      IS_INITIALIZED = .TRUE.
+   ENDIF
+   TEMPNAME = REPEAT(' ', LEN(PATH_) + LEN(PREFIX_) + 10) ! [PATH_] + [PREFIX_] + 6 RANDOM CHARS + [.TMP]
+   DO
+      CALL RANDOM_NUMBER(RANDOM_REAL)
+      RANDOM_INTEGER = TRANSFER(RANDOM_REAL, RANDOM_INTEGER)
+      RANDOM_INTEGER = IAND(RANDOM_INTEGER, 16777215_I4P)
+      IF (IS_FILE_)  THEN
+         WRITE(TEMPNAME, '(A,Z6.6,A)') PATH_//PREFIX_, RANDOM_INTEGER, '.TMP'
+      ELSE
+         WRITE(TEMPNAME, '(A,Z6.6)') PATH_//PREFIX_, RANDOM_INTEGER
+         TEMPNAME = TRIM(TEMPNAME)
+      ENDIF
+      INQUIRE(FILE=TEMPNAME, EXIST=IS_HOLD)
+      IF (.NOT.IS_HOLD) EXIT
+   ENDDO
+   ENDFUNCTION TEMPNAME
+
+   ELEMENTAL FUNCTION TO_INTEGER_I1P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO INTEGER (I1P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< INTEGER(I1P) :: INTEGER_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '127'
+   !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I1P)
+   !< TEST_PASSED(1) = INTEGER_==127_I1P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   INTEGER(I1P),  INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   INTEGER(I1P)              :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_INTEGER_I1P
+
+#ifndef _NVF
+   ELEMENTAL FUNCTION TO_INTEGER_I2P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO INTEGER (I2P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< INTEGER(I2P) :: INTEGER_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '127'
+   !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I2P)
+   !< TEST_PASSED(1) = INTEGER_==127_I2P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   INTEGER(I2P),  INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   INTEGER(I2P)              :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_INTEGER_I2P
+#endif
+
+   ELEMENTAL FUNCTION TO_INTEGER_I4P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO INTEGER (I4P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< INTEGER(I4P) :: INTEGER_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '127'
+   !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I4P)
+   !< TEST_PASSED(1) = INTEGER_==127_I4P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   INTEGER(I4P),  INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   INTEGER(I4P)              :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_INTEGER_I4P
+
+   ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO INTEGER (I8P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< INTEGER(I8P) :: INTEGER_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '127'
+   !< INTEGER_ = ASTRING%TO_NUMBER(KIND=1_I8P)
+   !< TEST_PASSED(1) = INTEGER_==127_I8P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   INTEGER(I8P),  INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   INTEGER(I8P)              :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_INTEGER_I8P
+
+   ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO REAL (R4P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< REAL(R4P)    :: REAL_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '3.4E9'
+   !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R4P)
+   !< TEST_PASSED(1) = REAL_==3.4E9_R4P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   REAL(R4P),     INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   REAL(R4P)                 :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_REAL_R4P
+
+   ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO REAL (R8P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< REAL(R8P)    :: REAL_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '3.4E9'
+   !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R8P)
+   !< TEST_PASSED(1) = REAL_==3.4E9_R8P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   REAL(R8P),     INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   REAL(R8P)                 :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_REAL_R8P
+
+   ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER)
+   !< CAST STRING TO REAL (R16P).
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< REAL(R16P)   :: REAL_
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '3.4E9'
+   !< REAL_ = ASTRING%TO_NUMBER(KIND=1._R16P)
+   !< TEST_PASSED(1) = REAL_==3.4E9_R16P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF      !< THE STRING.
+   REAL(R16P),    INTENT(IN) :: KIND      !< MOLD PARAMETER FOR KIND DETECTION.
+   REAL(R16P)                :: TO_NUMBER !< THE NUMBER INTO THE STRING.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
+   ENDIF
+   ENDFUNCTION TO_REAL_R16P
+
+   ELEMENTAL FUNCTION UNESCAPE(SELF, TO_UNESCAPE, UNESC) RESULT(UNESCAPED)
+   !< UNESCAPE DOUBLE BACKSLASHES (OR CUSTOM ESCAPED CHARACTER).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = '^\\S \\D+\\S*'
+   !< TEST_PASSED(1) = (ASTRING%UNESCAPE(TO_UNESCAPE='\')//''=='^\S \D+\S*')
+   !< TEST_PASSED(2) = (ASTRING%UNESCAPE(TO_UNESCAPE='S')//''=='^\S \\D+\S*')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF        !< THE STRING.
+   CHARACTER(KIND=CK, LEN=1), INTENT(IN)           :: TO_UNESCAPE !< CHARACTER TO BE UNESCAPED.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: UNESC       !< CHARACTER USED TO UNESCAPE.
+   TYPE(STRING)                                    :: UNESCAPED   !< ESCAPED STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: UNESC_      !< CHARACTER TO UNESCAPE, LOCAL VARIABLE.
+   INTEGER                                         :: C           !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      UNESC_ = '' ; IF (PRESENT(UNESC)) UNESC_ = UNESC
+      UNESCAPED%RAW = ''
+      C = 1
+      DO
+         IF (C>LEN(SELF%RAW)) EXIT
+         IF (C==LEN(SELF%RAW)) THEN
+            UNESCAPED%RAW = UNESCAPED%RAW//SELF%RAW(C:C)
+            EXIT
+         ELSE
+            IF (SELF%RAW(C:C+1)==BACKSLASH//TO_UNESCAPE) THEN
+               UNESCAPED%RAW = UNESCAPED%RAW//TO_UNESCAPE
+               C = C + 2
+            ELSE
+               UNESCAPED%RAW = UNESCAPED%RAW//SELF%RAW(C:C)
+               C = C + 1
+            ENDIF
+         ENDIF
+      ENDDO
+   ENDIF
+   ENDFUNCTION UNESCAPE
+
+   ELEMENTAL FUNCTION UNIQUE(SELF, SUBSTRING) RESULT(UNIQ)
+   !< REDUCE TO ONE (UNIQUE) MULTIPLE (SEQUENTIAL) OCCURRENCES OF A SUBSTRING INTO A STRING.
+   !<
+   !< FOR EXAMPLE THE STRING ' AB-CRE-CRE-AB' IS REDUCE TO 'AB-CRE-AB' IF THE SUBSTRING IS '-CRE'.
+   !< @NOTE EVENTUAL MULTIPLE TRAILING WHITE SPACE ARE NOT REDUCED TO ONE OCCURRENCE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = '+++AB-++CRE-++CRE-AB+++++'
+   !< TEST_PASSED(1) = ASTRING%UNIQUE(SUBSTRING='+')//''=='+AB-+CRE-+CRE-AB+'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF       !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SUBSTRING  !< SUBSTRING WHICH MULTIPLE OCCURENCES MUST BE REDUCED TO ONE.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SUBSTRING_ !< SUBSTRING, DEFAULT VALUE.
+   TYPE(STRING)                                    :: UNIQ       !< STRING PARSED.
+#ifdef _NVF
+   CHARACTER(9999)                                 :: NVF_BUG  !< WORK AROUND FOR NVFORTRAN BUG.
+#endif
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+     SUBSTRING_ = SPACE ; IF (PRESENT(SUBSTRING)) SUBSTRING_ = SUBSTRING
+
+     UNIQ = SELF
+     DO
+#ifdef _NVF
+       NVF_BUG = SUBSTRING_
+       IF (.NOT.UNIQ%INDEX(REPEAT(TRIM(NVF_BUG), 2))>0) EXIT
+       UNIQ = UNIQ%REPLACE(OLD=REPEAT(TRIM(NVF_BUG), 2), NEW=SUBSTRING_)
+#else
+       IF (.NOT.UNIQ%INDEX(REPEAT(SUBSTRING_, 2))>0) EXIT
+       UNIQ = UNIQ%REPLACE(OLD=REPEAT(SUBSTRING_, 2), NEW=SUBSTRING_)
+#endif
+     ENDDO
+   ENDIF
+   ENDFUNCTION UNIQUE
+
+   ELEMENTAL FUNCTION UPPER(SELF)
+   !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO WORLD!'
+   !< TEST_PASSED(1) = ASTRING%UPPER()//''=='HELLO WORLD!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF  !< THE STRING.
+   TYPE(STRING)              :: UPPER !< UPPER CASE STRING.
+   INTEGER                   :: N1    !< CHARACTERS COUNTER.
+   INTEGER                   :: N2    !< CHARACTERS COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      UPPER = SELF
+      DO N1=1, LEN(SELF%RAW)
+         N2 = INDEX(LOWER_ALPHABET, SELF%RAW(N1:N1))
+         IF (N2>0) UPPER%RAW(N1:N1) = UPPER_ALPHABET(N2:N2)
+      ENDDO
+   ENDIF
+   ENDFUNCTION UPPER
+
+   SUBROUTINE WRITE_FILE(SELF, FILE, FORM, IOSTAT, IOMSG)
+   !< WRITE A SINGLE STRING STREAM INTO FILE.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING)              :: ANOTHERSTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< TYPE(STRING)              :: LINE(3)
+   !< INTEGER                   :: IOSTAT
+   !< CHARACTER(LEN=99)         :: IOMSG
+   !< INTEGER                   :: SCRATCH
+   !< INTEGER                   :: L
+   !< LOGICAL                   :: TEST_PASSED(8)
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< ANOTHERSTRING = ANOTHERSTRING%JOIN(ARRAY=LINE, SEP=NEW_LINE('A'))
+   !< CALL ANOTHERSTRING%WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+1) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< CALL ANOTHERSTRING%WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+5) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='WRITE_FILE_TEST.TMP')
+   !< CLOSE(UNIT=SCRATCH, STATUS='DELETE')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),    INTENT(IN)              :: SELF    !< THE STRING.
+   CHARACTER(LEN=*), INTENT(IN)              :: FILE    !< FILE NAME.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM    !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT  !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG   !< IO STATUS MESSAGE.
+   TYPE(STRING)                              :: FORM_   !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                   :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE             :: IOMSG_  !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   INTEGER                                   :: UNIT    !< LOGICAL UNIT.
+
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+   SELECT CASE(FORM_%CHARS())
+   CASE('FORMATTED')
+      OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+   CASE('UNFORMATTED')
+      OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', FORM='UNFORMATTED', ACCESS='STREAM', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+   ENDSELECT
+   CALL SELF%WRITE_LINES(UNIT=UNIT, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_)
+   10 CLOSE(UNIT)
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE WRITE_FILE
+
+   SUBROUTINE WRITE_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG)
+   !< WRITE LINE (RECORD) TO A CONNECTED UNIT.
+   !<
+   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE.
+   !<
+   !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS.
+   CLASS(STRING),    INTENT(IN)              :: SELF    !< THE STRING.
+   INTEGER,          INTENT(IN)              :: UNIT    !< LOGICAL UNIT.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM    !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT  !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG   !< IO STATUS MESSAGE.
+   TYPE(STRING)                              :: FORM_   !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                   :: IOSTAT_ !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE             :: IOMSG_  !< IO STATUS MESSAGE, LOCAL VARIABLE.
+
+   IOSTAT_ = 0
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   IF (ALLOCATED(SELF%RAW)) THEN
+      FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+      SELECT CASE(FORM_%CHARS())
+      CASE('FORMATTED')
+         WRITE(UNIT, "(A)", IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW
+      CASE('UNFORMATTED')
+         IF (SELF%END_WITH(NEW_LINE('A'))) THEN
+            WRITE(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW
+         ELSE
+            WRITE(UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_) SELF%RAW//NEW_LINE('A')
+         ENDIF
+      ENDSELECT
+   ENDIF
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE WRITE_LINE
+
+   SUBROUTINE WRITE_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG)
+   !< WRITE LINES (RECORDS) TO A CONNECTED UNIT.
+   !<
+   !< THIS METHOD CHECKS IF SELF CONTAINS MORE THAN ONE LINE (RECORDS) AND WRITES THEM AS LINES (RECORDS).
+   !<
+   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE.
+   !<
+   !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS.
+   CLASS(STRING),    INTENT(IN)              :: SELF     !< THE STRING.
+   INTEGER,          INTENT(IN)              :: UNIT     !< LOGICAL UNIT.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM     !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT   !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG    !< IO STATUS MESSAGE.
+   TYPE(STRING), ALLOCATABLE                 :: LINES(:) !< LINES.
+   INTEGER                                   :: L        !< COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      CALL SELF%SPLIT(TOKENS=LINES, SEP=NEW_LINE('A'))
+      DO L=1, SIZE(LINES, DIM=1)
+         CALL LINES(L)%WRITE_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT, IOMSG=IOMSG)
+      ENDDO
+   ENDIF
+   ENDSUBROUTINE WRITE_LINES
+
+   ! INQUIRE
+   ELEMENTAL FUNCTION END_WITH(SELF, SUFFIX, START, END, IGNORE_NULL_EOF)
+   !< RETURN TRUE IF A STRING ENDS WITH A SPECIFIED SUFFIX.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(5)
+   !< ASTRING = 'HELLO WORLD!'
+   !< TEST_PASSED(1) = ASTRING%END_WITH(SUFFIX='LD!').EQV..TRUE.
+   !< TEST_PASSED(2) = ASTRING%END_WITH(SUFFIX='LD!').EQV..FALSE.
+   !< TEST_PASSED(3) = ASTRING%END_WITH(SUFFIX='ORLD!', START=5).EQV..TRUE.
+   !< TEST_PASSED(4) = ASTRING%END_WITH(SUFFIX='ORLD!', START=8, END=12).EQV..TRUE.
+   !< TEST_PASSED(5) = ASTRING%END_WITH(SUFFIX='!').EQV..TRUE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF             !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: SUFFIX           !< SEARCHED SUFFIX.
+   INTEGER,                   INTENT(IN), OPTIONAL :: START            !< START POSITION INTO THE STRING.
+   INTEGER,                   INTENT(IN), OPTIONAL :: END              !< END POSITION INTO THE STRING.
+   LOGICAL,                   INTENT(IN), OPTIONAL :: IGNORE_NULL_EOF  !< IGNORE NULL CHARACTER AT THE END OF FILE.
+   LOGICAL                                         :: END_WITH         !< RESULT OF THE TEST.
+   INTEGER                                         :: START_           !< START POSITION INTO THE STRING, LOCAL VARIABLE.
+   INTEGER                                         :: END_             !< END POSITION INTO THE STRING, LOCAL VARIABLE.
+   LOGICAL                                         :: IGNORE_NULL_EOF_ !< IGNORE NULL CHARACTER AT THE END OF FILE, LOCAL VARIABLE.
+
+   END_WITH = .FALSE.
+   IF (ALLOCATED(SELF%RAW)) THEN
+      START_           = 1             ; IF (PRESENT(START))           START_           = START
+      END_             = LEN(SELF%RAW) ; IF (PRESENT(END))             END_             = END
+      IGNORE_NULL_EOF_ = .FALSE.       ; IF (PRESENT(IGNORE_NULL_EOF)) IGNORE_NULL_EOF_ = IGNORE_NULL_EOF
+      IF (IGNORE_NULL_EOF_.AND.(SELF%RAW(END_:END_) == CHAR(0))) END_ = END_ - 1
+      IF (LEN(SUFFIX) <= LEN(SELF%RAW(START_:END_))) THEN
+         END_WITH = SELF%RAW(END_-LEN(SUFFIX)+1:END_) == SUFFIX
+      ENDIF
+   ENDIF
+   ENDFUNCTION END_WITH
+
+   ELEMENTAL FUNCTION IS_ALLOCATED(SELF)
+   !< RETURN TRUE IF THE STRING IS ALLOCATED.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< TEST_PASSED(1) = ASTRING%IS_ALLOCATED().EQV..FALSE.
+   !< ASTRING = 'HELLO'
+   !< TEST_PASSED(2) = ASTRING%IS_ALLOCATED().EQV..TRUE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   LOGICAL                   :: IS_ALLOCATED !< RESULT OF THE TEST.
+
+   IS_ALLOCATED = ALLOCATED(SELF%RAW)
+   ENDFUNCTION IS_ALLOCATED
+
+   ELEMENTAL FUNCTION IS_DIGIT(SELF)
+   !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE DIGITS.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = '   -1212112.3 '
+   !< TEST_PASSED(1) = ASTRING%IS_DIGIT().EQV..FALSE.
+   !< ASTRING = '12121123'
+   !< TEST_PASSED(2) = ASTRING%IS_DIGIT().EQV..TRUE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   LOGICAL                   :: IS_DIGIT !< RESULT OF THE TEST.
+   INTEGER                   :: C        !< CHARACTER COUNTER.
+
+   IS_DIGIT = .FALSE.
+   IF (ALLOCATED(SELF%RAW)) THEN
+      DO C=1, LEN(SELF%RAW)
+         SELECT CASE (SELF%RAW(C:C))
+         CASE ('0':'9')
+            IS_DIGIT = .TRUE.
+         CASE DEFAULT
+            IS_DIGIT = .FALSE.
+            EXIT
+         END SELECT
+      ENDDO
+   ENDIF
+   ENDFUNCTION IS_DIGIT
+
+   ELEMENTAL FUNCTION IS_INTEGER(SELF, ALLOW_SPACES)
+   !< RETURN TRUE IF THE STRING CONTAINS AN INTEGER.
+   !<
+   !< THE REGULAR EXPRESSION IS `\S*[\+\-]?\D+([EE]\+?\D+)?\S*`. THE PARSE ALGORITHM IS DONE IN STAGES:
+   !<
+   !< | S0  | S1      | S2  | S3   | S4  | S5  | S6  |
+   !< |-----|---------|-----|------|-----|-----|-----|
+   !< |`\S*`|`[\+\-]?`|`\D+`|`[EE]`|`\+?`|`\D+`|`\S*`|
+   !<
+   !< EXIT ON STAGES-PARSING RESULTS IN:
+   !<
+   !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 |
+   !< |----|----|----|----|----|----|----|
+   !< |  F |  F |  T |  F |  F |  T |  T |
+   !<
+   !< @NOTE THIS IMPLEMENTATION IS COURTESY OF
+   !< [TOMEDUNN](HTTPS://GITHUB.COM/TOMEDUNN/FORTRAN-STRING-UTILITY-MODULE/BLOB/MASTER/SRC/STRING_UTILITY_MODULE.F90#L294)
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(6)
+   !< ASTRING = '   -1212112 '
+   !< TEST_PASSED(1) = ASTRING%IS_INTEGER().EQV..TRUE.
+   !< ASTRING = '   -1212112'
+   !< TEST_PASSED(2) = ASTRING%IS_INTEGER(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '-1212112   '
+   !< TEST_PASSED(3) = ASTRING%IS_INTEGER(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '+2E20'
+   !< TEST_PASSED(4) = ASTRING%IS_INTEGER().EQV..TRUE.
+   !< ASTRING = ' -2E13 '
+   !< TEST_PASSED(5) = ASTRING%IS_INTEGER().EQV..TRUE.
+   !< ASTRING = ' -2 E13 '
+   !< TEST_PASSED(6) = ASTRING%IS_INTEGER().EQV..FALSE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF          !< THE STRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: ALLOW_SPACES  !< ALLOW LEADING-TRAILING SPACES.
+   LOGICAL                             :: IS_INTEGER    !< RESULT OF THE TEST.
+   LOGICAL                             :: ALLOW_SPACES_ !< ALLOW LEADING-TRAILING SPACES, LOCAL VARIABLE.
+   INTEGER                             :: STAGE         !< STAGES COUNTER.
+   INTEGER                             :: C             !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      ALLOW_SPACES_ = .TRUE. ; IF (PRESENT(ALLOW_SPACES)) ALLOW_SPACES_ = ALLOW_SPACES
+      STAGE = 0
+      IS_INTEGER = .TRUE.
+      DO C=1, LEN(SELF%RAW)
+         SELECT CASE(SELF%RAW(C:C))
+         CASE(SPACE, TAB)
+            SELECT CASE(STAGE)
+            CASE(0, 6)
+               IS_INTEGER = ALLOW_SPACES_
+            CASE(2, 5)
+               IS_INTEGER = ALLOW_SPACES_
+               STAGE = 6
+            CASE DEFAULT
+               IS_INTEGER = .FALSE.
+            ENDSELECT
+         CASE('-')
+            SELECT CASE(STAGE)
+            CASE(0)
+               STAGE = 1
+            CASE DEFAULT
+               IS_INTEGER = .FALSE.
+            END SELECT
+         CASE('+')
+            SELECT CASE(STAGE)
+            CASE(0)
+               STAGE = 1
+            CASE(3)
+               STAGE = 4
+            CASE DEFAULT
+               IS_INTEGER = .FALSE.
+            ENDSELECT
+         CASE('0':'9')
+            SELECT CASE(STAGE)
+            CASE(0:1)
+               STAGE = 2
+            CASE(3:4)
+               STAGE = 5
+            CASE DEFAULT
+               CONTINUE
+            ENDSELECT
+         CASE ('e','E')
+            SELECT CASE(STAGE)
+            CASE(2)
+               STAGE = 3
+            CASE DEFAULT
+               IS_INTEGER = .FALSE.
+            ENDSELECT
+         CASE DEFAULT
+            IS_INTEGER = .FALSE.
+         ENDSELECT
+         IF (.NOT.IS_INTEGER) EXIT
+      ENDDO
+   ENDIF
+   IF (IS_INTEGER) THEN
+      SELECT CASE(STAGE)
+      CASE(2, 5, 6)
+         IS_INTEGER = .TRUE.
+      CASE DEFAULT
+         IS_INTEGER = .FALSE.
+      END SELECT
+   ENDIF
+   ENDFUNCTION IS_INTEGER
+
+   ELEMENTAL FUNCTION IS_LOWER(SELF)
+   !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE LOWERCASE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(1) = ASTRING%IS_LOWER().EQV..FALSE.
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(2) = ASTRING%IS_LOWER().EQV..FALSE.
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(3) = ASTRING%IS_LOWER().EQV..TRUE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   LOGICAL                   :: IS_LOWER !< RESULT OF THE TEST.
+   INTEGER                   :: C        !< CHARACTER COUNTER.
+
+   IS_LOWER = .FALSE.
+   IF (ALLOCATED(SELF%RAW)) THEN
+      IS_LOWER = .TRUE.
+      DO C=1, LEN(SELF%RAW)
+         IF (INDEX(UPPER_ALPHABET, SELF%RAW(C:C))>0) THEN
+            IS_LOWER = .FALSE.
+            EXIT
+         ENDIF
+      ENDDO
+   ENDIF
+   ENDFUNCTION IS_LOWER
+
+   ELEMENTAL FUNCTION IS_NUMBER(SELF, ALLOW_SPACES)
+   !< RETURN TRUE IF THE STRING CONTAINS A NUMBER (REAL OR INTEGER).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(7)
+   !< ASTRING = '   -1212112 '
+   !< TEST_PASSED(1) = ASTRING%IS_NUMBER().EQV..TRUE.
+   !< ASTRING = '   -121.2112 '
+   !< TEST_PASSED(2) = ASTRING%IS_NUMBER().EQV..TRUE.
+   !< ASTRING = '   -1212112'
+   !< TEST_PASSED(3) = ASTRING%IS_NUMBER(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '-12121.12   '
+   !< TEST_PASSED(4) = ASTRING%IS_NUMBER(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '+2E20'
+   !< TEST_PASSED(5) = ASTRING%IS_NUMBER().EQV..TRUE.
+   !< ASTRING = ' -2.4E13 '
+   !< TEST_PASSED(6) = ASTRING%IS_NUMBER().EQV..TRUE.
+   !< ASTRING = ' -2 E13 '
+   !< TEST_PASSED(7) = ASTRING%IS_NUMBER().EQV..FALSE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF         !< THE STRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: ALLOW_SPACES !< ALLOW LEADING-TRAILING SPACES.
+   LOGICAL                             :: IS_NUMBER    !< RESULT OF THE TEST.
+
+   IS_NUMBER = (SELF%IS_INTEGER(ALLOW_SPACES=ALLOW_SPACES).OR.SELF%IS_REAL(ALLOW_SPACES=ALLOW_SPACES))
+   ENDFUNCTION IS_NUMBER
+
+   ELEMENTAL FUNCTION IS_REAL(SELF, ALLOW_SPACES)
+   !< RETURN TRUE IF THE STRING CONTAINS A REAL.
+   !<
+   !< THE REGULAR EXPRESSION IS `\S*[\+\-]?\D*(|\.?\D*([DEDE][\+\-]?\D+)?)\S*`. THE PARSE ALGORITHM IS DONE IN STAGES:
+   !<
+   !< | S0  | S1      | S2  | S3  | S4  | S5     | S6      | S7  | S8  |
+   !< |-----|---------|-----|-----|-----|--------|---------|-----|-----|
+   !< |`\S*`|`[\+\-]?`|`\D*`|`\.?`|`\D*`|`[DEDE]`|`[\+\-]?`|`\D*`|`\S*`|
+   !<
+   !< EXIT ON STAGES-PARSING RESULTS IN:
+   !<
+   !< | S0 | S1 | S2 | S3 | S4 | S5 | S6 | S7 | S8 |
+   !< |----|----|----|----|----|----|----|----|----|
+   !  |  F |  F |  T |  T |  T |  F |  F |  T |  T |
+   !<
+   !< @NOTE THIS IMPLEMENTATION IS COURTESY OF
+   !< [TOMEDUNN](HTTPS://GITHUB.COM/TOMEDUNN/FORTRAN-STRING-UTILITY-MODULE/BLOB/MASTER/SRC/STRING_UTILITY_MODULE.F90#L614)
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(6)
+   !< ASTRING = '   -1212112.D0 '
+   !< TEST_PASSED(1) = ASTRING%IS_REAL().EQV..TRUE.
+   !< ASTRING = '   -1212112.D0'
+   !< TEST_PASSED(2) = ASTRING%IS_REAL(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '-1212112.D0   '
+   !< TEST_PASSED(3) = ASTRING%IS_REAL(ALLOW_SPACES=.FALSE.).EQV..FALSE.
+   !< ASTRING = '+2.E20'
+   !< TEST_PASSED(4) = ASTRING%IS_REAL().EQV..TRUE.
+   !< ASTRING = ' -2.01E13 '
+   !< TEST_PASSED(5) = ASTRING%IS_REAL().EQV..TRUE.
+   !< ASTRING = ' -2.01 E13 '
+   !< TEST_PASSED(6) = ASTRING%IS_REAL().EQV..FALSE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)           :: SELF              !< THE STRING.
+   LOGICAL,       INTENT(IN), OPTIONAL :: ALLOW_SPACES      !< ALLOW LEADING-TRAILING SPACES.
+   LOGICAL                             :: IS_REAL           !< RESULT OF THE TEST.
+   LOGICAL                             :: ALLOW_SPACES_     !< ALLOW LEADING-TRAILING SPACES, LOCAL VARIABLE.
+   LOGICAL                             :: HAS_LEADING_DIGIT !< CHECK THE PRESENCE OF LEADING DIGITS.
+   INTEGER                             :: STAGE             !< STAGES COUNTER.
+   INTEGER                             :: C                 !< CHARACTER COUNTER.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      ALLOW_SPACES_ = .TRUE. ; IF (PRESENT(ALLOW_SPACES)) ALLOW_SPACES_ = ALLOW_SPACES
+      STAGE = 0
+      IS_REAL = .TRUE.
+      HAS_LEADING_DIGIT = .FALSE.
+      DO C=1, LEN(SELF%RAW)
+         SELECT CASE(SELF%RAW(C:C))
+         CASE(SPACE, TAB)
+            SELECT CASE(STAGE)
+            CASE(0, 8)
+               IS_REAL = ALLOW_SPACES_
+               CONTINUE
+            CASE(2:4, 7)
+               IS_REAL = ALLOW_SPACES_
+               STAGE = 8
+            CASE DEFAULT
+               IS_REAL = .FALSE.
+            ENDSELECT
+         CASE('+', '-')
+            SELECT CASE(STAGE)
+            CASE(0)
+               STAGE = 1
+            CASE(5)
+               STAGE = 6
+            CASE DEFAULT
+               IS_REAL = .FALSE.
+            ENDSELECT
+         CASE('0':'9')
+            SELECT CASE(STAGE)
+            CASE(0:1)
+               STAGE = 2
+               HAS_LEADING_DIGIT = .TRUE.
+            CASE(3)
+               STAGE = 4
+            CASE(5:6)
+               STAGE = 7
+            CASE DEFAULT
+               CONTINUE
+            ENDSELECT
+         CASE('.')
+            SELECT CASE(STAGE)
+            CASE(0:2)
+               STAGE = 3
+            CASE DEFAULT
+               IS_REAL = .FALSE.
+            ENDSELECT
+         CASE('e','E','d','D')
+            SELECT CASE(STAGE)
+            CASE(2:4)
+               STAGE = 5
+            CASE DEFAULT
+               IS_REAL = .FALSE.
+            ENDSELECT
+         CASE DEFAULT
+            IS_REAL = .FALSE.
+         ENDSELECT
+         IF (.NOT.IS_REAL) EXIT
+      ENDDO
+   ENDIF
+   IF (IS_REAL) THEN
+      SELECT CASE(STAGE)
+      CASE(2, 4, 7, 8)
+         IS_REAL = .TRUE.
+      CASE(3)
+         IS_REAL = HAS_LEADING_DIGIT
+      CASE DEFAULT
+         IS_REAL = .FALSE.
+      ENDSELECT
+   ENDIF
+   ENDFUNCTION IS_REAL
+
+   ELEMENTAL FUNCTION IS_UPPER(SELF)
+   !< RETURN TRUE IF ALL CHARACTERS IN THE STRING ARE UPPERCASE.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(1) = ASTRING%IS_UPPER().EQV..FALSE.
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(2) = ASTRING%IS_UPPER().EQV..TRUE.
+   !< ASTRING = ' HELLO WORLD'
+   !< TEST_PASSED(3) = ASTRING%IS_UPPER().EQV..FALSE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: SELF     !< THE STRING.
+   LOGICAL                   :: IS_UPPER !< RESULT OF THE TEST.
+   INTEGER                   :: C        !< CHARACTER COUNTER.
+
+   IS_UPPER = .FALSE.
+   IF (ALLOCATED(SELF%RAW)) THEN
+      IS_UPPER = .TRUE.
+      DO C=1, LEN(SELF%RAW)
+         IF (INDEX(LOWER_ALPHABET, SELF%RAW(C:C))>0) THEN
+            IS_UPPER = .FALSE.
+            EXIT
+         ENDIF
+      ENDDO
+   ENDIF
+   ENDFUNCTION IS_UPPER
+
+   ELEMENTAL FUNCTION START_WITH(SELF, PREFIX, START, END)
+   !< RETURN TRUE IF A STRING STARTS WITH A SPECIFIED PREFIX.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(4)
+   !< ASTRING = 'HELLO WORLD!'
+   !< TEST_PASSED(1) = ASTRING%START_WITH(PREFIX='HELLO').EQV..TRUE.
+   !< TEST_PASSED(2) = ASTRING%START_WITH(PREFIX='HELL').EQV..FALSE.
+   !< TEST_PASSED(3) = ASTRING%START_WITH(PREFIX='LLO WOR', START=3).EQV..TRUE.
+   !< TEST_PASSED(4) = ASTRING%START_WITH(PREFIX='LO W', START=4, END=7).EQV..TRUE.
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)           :: SELF       !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: PREFIX     !< SEARCHED PREFIX.
+   INTEGER,                   INTENT(IN), OPTIONAL :: START      !< START POSITION INTO THE STRING.
+   INTEGER,                   INTENT(IN), OPTIONAL :: END        !< END POSITION INTO THE STRING.
+   LOGICAL                                         :: START_WITH !< RESULT OF THE TEST.
+   INTEGER                                         :: START_     !< START POSITION INTO THE STRING, LOCAL VARIABLE.
+   INTEGER                                         :: END_       !< END POSITION INTO THE STRING, LOCAL VARIABLE.
+
+   START_WITH = .FALSE.
+   IF (ALLOCATED(SELF%RAW)) THEN
+      START_ = 1             ; IF (PRESENT(START)) START_ = START
+      END_   = LEN(SELF%RAW) ; IF (PRESENT(END))   END_   = END
+      IF (LEN(PREFIX)<=LEN(SELF%RAW(START_:END_))) THEN
+         START_WITH = INDEX(SELF%RAW(START_:END_), PREFIX)==1
+      ENDIF
+   ENDIF
+   ENDFUNCTION START_WITH
+
+   ! PRIVATE METHODS
+
+   ! ASSIGNMENTS
+   PURE SUBROUTINE STRING_ASSIGN_STRING(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM STRING INPUT.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO'
+   !< ANOTHERSTRING = ASTRING
+   !< TEST_PASSED(1) = ASTRING%CHARS()==ANOTHERSTRING%CHARS()
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   IF (ALLOCATED(RHS%RAW)) LHS%RAW = RHS%RAW
+   ENDSUBROUTINE STRING_ASSIGN_STRING
+
+   PURE SUBROUTINE STRING_ASSIGN_CHARACTER(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM CHARACTER INPUT.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO'
+   !< TEST_PASSED(1) = ASTRING%CHARS()=='HELLO'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = RHS
+   ENDSUBROUTINE STRING_ASSIGN_CHARACTER
+
+   PURE SUBROUTINE STRING_ASSIGN_INTEGER_I1P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 127_I1P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I1P)==127_I1P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   INTEGER(I1P),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_INTEGER_I1P
+
+   PURE SUBROUTINE STRING_ASSIGN_INTEGER_I2P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 127_I2P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I2P)==127_I2P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   INTEGER(I2P),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_INTEGER_I2P
+
+   PURE SUBROUTINE STRING_ASSIGN_INTEGER_I4P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 127_I4P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I4P)==127_I4P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   INTEGER(I4P),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_INTEGER_I4P
+
+   PURE SUBROUTINE STRING_ASSIGN_INTEGER_I8P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM INTEGER INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 127_I8P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1_I8P)==127_I8P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   INTEGER(I8P),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_INTEGER_I8P
+
+   PURE SUBROUTINE STRING_ASSIGN_REAL_R4P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 3.021E6_R4P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R4P)==3.021E6_R4P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   REAL(R4P),     INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_REAL_R4P
+
+   PURE SUBROUTINE STRING_ASSIGN_REAL_R8P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 3.021E6_R8P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R8P)==3.021E6_R8P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   REAL(R8P),     INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_REAL_R8P
+
+   PURE SUBROUTINE STRING_ASSIGN_REAL_R16P(LHS, RHS)
+   !< ASSIGNMENT OPERATOR FROM REAL INPUT.
+   !<
+   !<```FORTRAN
+   !< USE PENF
+   !< TYPE(STRING) :: ASTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 3.021E6_R8P
+   !< TEST_PASSED(1) = ASTRING%TO_NUMBER(KIND=1._R8P)==3.021E6_R8P
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+   REAL(R16P),    INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+
+   LHS%RAW = TRIM(STR(RHS))
+   ENDSUBROUTINE STRING_ASSIGN_REAL_R16P
+
+   ! CONTATENATION OPERATORS
+   PURE FUNCTION STRING_CONCAT_STRING(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ANOTHERSTRING = 'BYE BYE'
+   !< TEST_PASSED(1) = ASTRING//ANOTHERSTRING=='HELLO BYE BYE'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: LHS    !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN)              :: RHS    !< RIGHT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING.
+
+   CONCAT = ''
+   IF (ALLOCATED(LHS%RAW)) CONCAT = LHS%RAW
+   IF (ALLOCATED(RHS%RAW)) CONCAT = CONCAT//RHS%RAW
+   ENDFUNCTION STRING_CONCAT_STRING
+
+   PURE FUNCTION STRING_CONCAT_CHARACTER(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH CHARACTER.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ACHARACTER = 'WORLD!'
+   !< TEST_PASSED(1) = ASTRING//ACHARACTER=='HELLO WORLD!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)  :: LHS    !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: RHS    !< RIGHT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING.
+
+   IF (ALLOCATED(LHS%RAW)) THEN
+      CONCAT = LHS%RAW//RHS
+   ELSE
+      CONCAT = RHS
+   ENDIF
+   ENDFUNCTION STRING_CONCAT_CHARACTER
+
+   PURE FUNCTION CHARACTER_CONCAT_STRING(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH CHARACTER (INVERTED).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ACHARACTER = 'WORLD!'
+   !< TEST_PASSED(1) = ACHARACTER//ASTRING=='WORLD!HELLO '
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: LHS    !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN)  :: RHS    !< RIGHT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: CONCAT !< CONCATENATED STRING.
+
+   IF (ALLOCATED(RHS%RAW)) THEN
+      CONCAT = LHS//RHS%RAW
+   ELSE
+      CONCAT = LHS
+   ENDIF
+   ENDFUNCTION CHARACTER_CONCAT_STRING
+
+   ELEMENTAL FUNCTION STRING_CONCAT_STRING_STRING(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH STRING.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< TYPE(STRING) :: YETANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ANOTHERSTRING = 'BYE BYE'
+   !< YETANOTHERSTRING = ASTRING.CAT.ANOTHERSTRING
+   !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='HELLO BYE BYE'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN)              :: LHS       !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN)              :: RHS       !< RIGHT HAND SIDE.
+   TYPE(STRING)                           :: CONCAT    !< CONCATENATED STRING.
+   CHARACTER(KIND=CK, LEN=:), ALLOCATABLE :: TEMPORARY !< TEMPORARY CONCATENATED STRING.
+
+   TEMPORARY = ''
+   IF (ALLOCATED(LHS%RAW)) TEMPORARY = LHS%RAW
+   IF (ALLOCATED(RHS%RAW)) TEMPORARY = TEMPORARY//RHS%RAW
+   IF (TEMPORARY/='') CONCAT%RAW = TEMPORARY
+   ENDFUNCTION STRING_CONCAT_STRING_STRING
+
+   ELEMENTAL FUNCTION STRING_CONCAT_CHARACTER_STRING(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH CHARACTER.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< TYPE(STRING)                  :: YETANOTHERSTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ACHARACTER = 'WORLD!'
+   !< YETANOTHERSTRING = ASTRING.CAT.ACHARACTER
+   !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='HELLO WORLD!'
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN)  :: LHS    !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: RHS    !< RIGHT HAND SIDE.
+   TYPE(STRING)                           :: CONCAT !< CONCATENATED STRING.
+
+   IF (ALLOCATED(LHS%RAW)) THEN
+      CONCAT%RAW = LHS%RAW//RHS
+   ELSE
+      CONCAT%RAW = RHS
+   ENDIF
+   ENDFUNCTION STRING_CONCAT_CHARACTER_STRING
+
+   ELEMENTAL FUNCTION CHARACTER_CONCAT_STRING_STRING(LHS, RHS) RESULT(CONCAT)
+   !< CONCATENATION WITH CHARACTER (INVERTED).
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< TYPE(STRING)                  :: YETANOTHERSTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(1)
+   !< ASTRING = 'HELLO '
+   !< ACHARACTER = 'WORLD!'
+   !< YETANOTHERSTRING = ACHARACTER.CAT.ASTRING
+   !< TEST_PASSED(1) = YETANOTHERSTRING%CHARS()=='WORLD!HELLO '
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: LHS    !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN)  :: RHS    !< RIGHT HAND SIDE.
+   TYPE(STRING)                           :: CONCAT !< CONCATENATED STRING.
+
+   IF (ALLOCATED(RHS%RAW)) THEN
+     CONCAT%RAW = LHS//RHS%RAW
+   ELSE
+     CONCAT%RAW = LHS
+   ENDIF
+   ENDFUNCTION CHARACTER_CONCAT_STRING_STRING
+
+   ! LOGICAL OPERATORS
+   ELEMENTAL FUNCTION STRING_EQ_STRING(LHS, RHS) RESULT(IS_IT)
+   !< EQUAL TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ANOTHERSTRING = 'TWO'
+   !< TEST_PASSED(1) = ((ASTRING==ANOTHERSTRING).EQV..FALSE.)
+   !< ASTRING = 'THE SAME '
+   !< ANOTHERSTRING = 'THE SAME '
+   !< TEST_PASSED(2) = ((ASTRING==ANOTHERSTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW == RHS%RAW
+   ENDFUNCTION STRING_EQ_STRING
+
+   ELEMENTAL FUNCTION STRING_EQ_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< EQUAL TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ACHARACTER = 'THREE'
+   !< TEST_PASSED(1) = ((ASTRING==ACHARACTER).EQV..FALSE.)
+   !< ASTRING = 'THE SAME '
+   !< ACHARACTER = 'THE SAME '
+   !< TEST_PASSED(2) = ((ASTRING==ACHARACTER).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW == RHS
+   ENDFUNCTION STRING_EQ_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_EQ_STRING(LHS, RHS) RESULT(IS_IT)
+   !< EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ACHARACTER = 'THREE'
+   !< TEST_PASSED(1) = ((ACHARACTER==ASTRING).EQV..FALSE.)
+   !< ASTRING = 'THE SAME '
+   !< ACHARACTER = 'THE SAME '
+   !< TEST_PASSED(2) = ((ACHARACTER==ASTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = RHS%RAW == LHS
+   ENDFUNCTION CHARACTER_EQ_STRING
+
+   ELEMENTAL FUNCTION STRING_NE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< NOT EQUAL TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ANOTHERSTRING = 'TWO'
+   !< TEST_PASSED(1) = ((ASTRING/=ANOTHERSTRING).EQV..TRUE.)
+   !< ASTRING = 'THE SAME '
+   !< ANOTHERSTRING = 'THE SAME '
+   !< TEST_PASSED(2) = ((ASTRING/=ANOTHERSTRING).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW /= RHS%RAW
+   ENDFUNCTION STRING_NE_STRING
+
+   ELEMENTAL FUNCTION STRING_NE_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< NOT EQUAL TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ACHARACTER = 'THREE'
+   !< TEST_PASSED(1) = ((ASTRING/=ACHARACTER).EQV..TRUE.)
+   !< ASTRING = 'THE SAME '
+   !< ACHARACTER = 'THE SAME '
+   !< TEST_PASSED(2) = ((ASTRING/=ACHARACTER).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW /= RHS
+   ENDFUNCTION STRING_NE_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_NE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< NOT EQUAL TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = '  ONE '
+   !< ACHARACTER = 'THREE'
+   !< TEST_PASSED(1) = ((ACHARACTER/=ASTRING).EQV..TRUE.)
+   !< ASTRING = 'THE SAME '
+   !< ACHARACTER = 'THE SAME '
+   !< TEST_PASSED(2) = ((ACHARACTER/=ASTRING).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = RHS%RAW /= LHS
+   ENDFUNCTION CHARACTER_NE_STRING
+
+   ELEMENTAL FUNCTION STRING_LT_STRING(LHS, RHS) RESULT(IS_IT)
+   !< LOWER THAN TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING<ANOTHERSTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING<ANOTHERSTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW < RHS%RAW
+   ENDFUNCTION STRING_LT_STRING
+
+   ELEMENTAL FUNCTION STRING_LT_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< LOWER THAN TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING<ACHARACTER).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING<ACHARACTER).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW < RHS
+   ENDFUNCTION STRING_LT_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_LT_STRING(LHS, RHS) RESULT(IS_IT)
+   !< LOWER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ACHARACTER<ASTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ACHARACTER<ASTRING).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS < RHS%RAW
+   ENDFUNCTION CHARACTER_LT_STRING
+
+   ELEMENTAL FUNCTION STRING_LE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< LOWER EQUAL THAN TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING<=ANOTHERSTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING<=ANOTHERSTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(3) = ((ASTRING<=ANOTHERSTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW <= RHS%RAW
+   ENDFUNCTION STRING_LE_STRING
+
+   ELEMENTAL FUNCTION STRING_LE_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< LOWER EQUAL THAN TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING<=ACHARACTER).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING<=ACHARACTER).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(3) = ((ASTRING<=ACHARACTER).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW <= RHS
+   ENDFUNCTION STRING_LE_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_LE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< LOWER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ACHARACTER<=ASTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ACHARACTER<=ASTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(3) = ((ACHARACTER<=ASTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS <= RHS%RAW
+   ENDFUNCTION CHARACTER_LE_STRING
+
+   ELEMENTAL FUNCTION STRING_GE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< GREATER EQUAL THAN TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING>=ANOTHERSTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING>=ANOTHERSTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(3) = ((ASTRING>=ANOTHERSTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW >= RHS%RAW
+   ENDFUNCTION STRING_GE_STRING
+
+   ELEMENTAL FUNCTION STRING_GE_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< GREATER EQUAL THAN TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING>=ACHARACTER).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING>=ACHARACTER).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(3) = ((ASTRING>=ACHARACTER).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW >= RHS
+   ENDFUNCTION STRING_GE_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_GE_STRING(LHS, RHS) RESULT(IS_IT)
+   !< GREATER EQUAL THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(3)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ACHARACTER>=ASTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ACHARACTER>=ASTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(3) = ((ACHARACTER>=ASTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS >= RHS%RAW
+   ENDFUNCTION CHARACTER_GE_STRING
+
+   ELEMENTAL FUNCTION STRING_GT_STRING(LHS, RHS) RESULT(IS_IT)
+   !< GREATER THAN TO STRING LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING) :: ASTRING
+   !< TYPE(STRING) :: ANOTHERSTRING
+   !< LOGICAL      :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING>ANOTHERSTRING).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ANOTHERSTRING = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING>ANOTHERSTRING).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   TYPE(STRING),  INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                   :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW > RHS%RAW
+   ENDFUNCTION STRING_GT_STRING
+
+   ELEMENTAL FUNCTION STRING_GT_CHARACTER(LHS, RHS) RESULT(IS_IT)
+   !< GREATER THAN TO CHARACTER LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ASTRING>ACHARACTER).EQV..TRUE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ASTRING>ACHARACTER).EQV..FALSE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CLASS(STRING),             INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS%RAW > RHS
+   ENDFUNCTION STRING_GT_CHARACTER
+
+   ELEMENTAL FUNCTION CHARACTER_GT_STRING(LHS, RHS) RESULT(IS_IT)
+   !< GREATER THAN TO CHARACTER (INVERTED) LOGICAL OPERATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)                  :: ASTRING
+   !< CHARACTER(LEN=:), ALLOCATABLE :: ACHARACTER
+   !< LOGICAL                       :: TEST_PASSED(2)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(1) = ((ACHARACTER>ASTRING).EQV..FALSE.)
+   !< ASTRING = 'ONE'
+   !< ACHARACTER = 'ONE'
+   !< TEST_PASSED(2) = ((ACHARACTER>ASTRING).EQV..TRUE.)
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN) :: LHS   !< LEFT HAND SIDE.
+   CLASS(STRING),             INTENT(IN) :: RHS   !< RIGHT HAND SIDE.
+   LOGICAL                               :: IS_IT !< OPREATOR TEST RESULT.
+
+   IS_IT = LHS > RHS%RAW
+   ENDFUNCTION CHARACTER_GT_STRING
+
+   ! IO
+   SUBROUTINE READ_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG)
+   !< FORMATTED INPUT.
+   !<
+   !< @BUG CHANGE TEMPORARY ACKS: FIND A MORE PRECISE LENGTH OF THE INPUT STRING AND AVOID THE TRIMMING!
+   !<
+   !< @BUG READ LISTDIRECTED WITH AND WITHOUT DELIMITERS DOES NOT WORK.
+   CLASS(STRING),             INTENT(INOUT) :: DTV         !< THE STRING.
+   INTEGER,                   INTENT(IN)    :: UNIT        !< LOGICAL UNIT.
+   CHARACTER(LEN=*),          INTENT(IN)    :: IOTYPE      !< EDIT DESCRIPTOR.
+   INTEGER,                   INTENT(IN)    :: V_LIST(:)   !< EDIT DESCRIPTOR LIST.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT      !< IO STATUS CODE.
+   CHARACTER(LEN=*),          INTENT(INOUT) :: IOMSG       !< IO STATUS MESSAGE.
+   CHARACTER(LEN=LEN(IOMSG))                :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED.
+   CHARACTER(KIND=CK, LEN=1)                :: DELIM       !< STRING DELIMITER, IF ANY.
+   CHARACTER(KIND=CK, LEN=100)              :: TEMPORARY   !< TEMPORARY STORAGE STRING.
+
+   IF (IOTYPE == 'LISTDIRECTED') THEN
+      CALL GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT=UNIT, CH=DELIM, IOSTAT=IOSTAT, IOMSG=IOMSG)
+      IF (IOSTAT/=0) RETURN
+      IF (DELIM=='"'.OR.DELIM=="'") THEN
+         CALL DTV%READ_DELIMITED(UNIT=UNIT, DELIM=DELIM, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG)
+      ELSE
+         ! STEP BACK BEFORE THE NON-BLANK
+         READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG)
+         IF (IOSTAT /= 0) RETURN
+         CALL DTV%READ_UNDELIMITED_LISTDIRECTED(UNIT=UNIT, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG)
+      ENDIF
+      IF (IS_IOSTAT_EOR(IOSTAT)) THEN
+         ! SUPPRESS IOSTAT_EOR
+         IOSTAT = 0
+      ELSEIF (IOSTAT /= 0) THEN
+         IOMSG = LOCAL_IOMSG
+      ENDIF
+      RETURN
+   ELSE
+      READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)TEMPORARY
+      DTV%RAW = TRIM(TEMPORARY)
+   ENDIF
+   ENDSUBROUTINE READ_FORMATTED
+
+   SUBROUTINE READ_DELIMITED(DTV, UNIT, DELIM, IOSTAT, IOMSG)
+   !< READ A DELIMITED STRING FROM A UNIT CONNECTED FOR FORMATTED INPUT.
+   !<
+   !< IF THE CLOSING DELIMITER IS FOLLOWED BY END OF RECORD, THEN WE RETURN END OF RECORD.
+   !<
+   !< @NOTE THIS DOES NOT NEED A DOCTEST, IT BEING TESTED BY [[STRING::READ_FORMATTED]].
+   CLASS(STRING),             INTENT(OUT)   :: DTV       !< THE STRING.
+   INTEGER,                   INTENT(IN)    :: UNIT      !< LOGICAL UNIT.
+   CHARACTER(KIND=CK, LEN=1), INTENT(IN)    :: DELIM     !< STRING DELIMITER.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT    !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG     !< IO STATUS MESSAGE.
+   CHARACTER(KIND=CK, LEN=1)                :: CH        !< A CHARACTER READ.
+   LOGICAL                                  :: WAS_DELIM !< INDICATES THAT THE LAST CHARACTER READ WAS A DELIMITER.
+
+   WAS_DELIM = .FALSE.
+   DTV%RAW = ''
+   DO
+      READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG) CH
+      IF (IS_IOSTAT_EOR(IOSTAT)) THEN
+         IF (WAS_DELIM) THEN
+           ! END OF DELIMITED STRING FOLLOWED BY END OF RECORD IS END OF THE STRING. PASS BACK THE
+           ! END OF RECORD CONDITION TO THE CALLER
+           RETURN
+         ELSE
+           ! END OF RECORD WITHOUT TERMINATING DELIMITER - MOVE ALONG
+           CYCLE
+         ENDIF
+      ELSEIF (IOSTAT /= 0) THEN
+        RETURN
+      ENDIF
+      IF (CH == DELIM) THEN
+         IF (WAS_DELIM) THEN
+            ! DOUBLED DELIMITER IS ONE DELIMITER IN THE VALUE
+            DTV%RAW = DTV%RAW // CH
+            WAS_DELIM = .FALSE.
+         ELSE
+            ! NEED TO TEST NEXT CHARACTER TO SEE WHAT IS HAPPENING
+            WAS_DELIM = .TRUE.
+         ENDIF
+      ELSEIF (WAS_DELIM) THEN
+         ! THE PREVIOUS CHARACTER WAS ACTUALLY THE DELIMITER FOR THE END OF THE STRING. PUT BACK THIS CHARACTER
+         READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG)
+         RETURN
+      ELSE
+         DTV%RAW = DTV%RAW // CH
+      ENDIF
+   ENDDO
+   ENDSUBROUTINE READ_DELIMITED
+
+  SUBROUTINE READ_UNDELIMITED_LISTDIRECTED(DTV, UNIT, IOSTAT, IOMSG)
+  !< READ AN UNDELIMITED (NO LEADING APOSTROPHE OR DOUBLE QUOTE) CHARACTER VALUE ACCORDING TO THE RULES FOR LIST DIRECTED INPUT.
+  !<
+  !< A BLANK, COMMA/SEMICOLON (DEPENDING ON THE DECIMAL MODE), SLASH OR END OF RECORD TERMINATES THE STRING.
+  !<
+  !< IF INPUT IS TERMINATED BY END OF RECORD, THEN THIS PROCEDURE RETURNS AN END-OF-RECORD CONDITION.
+  CLASS(STRING),    INTENT(INOUT) :: DTV           !< THE STRING.
+  INTEGER,          INTENT(IN)    :: UNIT          !< LOGICAL UNIT.
+  INTEGER,          INTENT(OUT)   :: IOSTAT        !< IO STATUS CODE.
+  CHARACTER(LEN=*), INTENT(INOUT) :: IOMSG         !< IO STATUS MESSAGE.
+  LOGICAL                         :: DECIMAL_POINT !<TRUE IF DECIMAL=POINT IN EFFECT.
+
+  CALL GET_DECIMAL_MODE(UNIT=UNIT, DECIMAL_POINT=DECIMAL_POINT, IOSTAT=IOSTAT, IOMSG=IOMSG)
+  IF (IOSTAT /= 0) RETURN
+  CALL DTV%READ_UNDELIMITED(UNIT=UNIT, TERMINATORS=' '//'/'//MERGE(CK_',', CK_';', DECIMAL_POINT), IOSTAT=IOSTAT, IOMSG=IOMSG)
+  ENDSUBROUTINE READ_UNDELIMITED_LISTDIRECTED
+
+  SUBROUTINE READ_UNDELIMITED(DTV, UNIT, TERMINATORS, IOSTAT, IOMSG)
+  !< READ AN UNDELIMITED STRING UP UNTIL END OF RECORD OR A CHARACTER FROM A SET OF TERMINATORS IS ENCOUNTERED.
+  !<
+  !< IF A TERMINATOR IS ENCOUNTERED, THE FILE POSITION WILL BE AT THAT TERMINATING CHARACTER. IF END OF RECORD IS ENCOUNTERED, THE
+  !< FILE REMAINS AT END OF RECORD.
+  CLASS(STRING),             INTENT(INOUT) :: DTV         !< THE STRING.
+  INTEGER,                   INTENT(IN)    :: UNIT        !< LOGICAL UNIT.
+  CHARACTER(KIND=CK, LEN=*), INTENT(IN)    :: TERMINATORS !< CHARACTERS THAT ARE CONSIDERED TO TERMINATE THE STRING.
+                                                          !< BLANKS IN THIS STRING ARE MEANINGFUL.
+  INTEGER,                   INTENT(OUT)   :: IOSTAT      !< IO STATUS CODE.
+  CHARACTER(LEN=*),          INTENT(INOUT) :: IOMSG       !< IO STATUS MESSAGE.
+  CHARACTER(KIND=CK, LEN=1)                :: CH          !< A CHARACTER READ.
+
+  DTV%RAW = ''
+  DO
+    READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG) CH
+    IF (IS_IOSTAT_EOR(IOSTAT)) THEN
+      ! END OF RECORD JUST MEANS END OF STRING. WE PASS ON THE CONDITION
+      RETURN
+    ELSEIF (IOSTAT /= 0) THEN
+      ! SOMETHING ODD HAPPENED
+      RETURN
+    ENDIF
+    IF (SCAN(CH, TERMINATORS) /= 0) THEN
+      ! CHANGE THE FILE POSITION SO THAT THE NEXT READ SEES THE TERMINATOR
+      READ(UNIT, "(TL1)", IOSTAT=IOSTAT, IOMSG=IOMSG)
+      IF (IOSTAT /= 0) RETURN
+      IOSTAT = 0
+      RETURN
+    ENDIF
+    ! WE GOT A CHARACTER - APPEND IT
+    DTV%RAW = DTV%RAW // CH
+  ENDDO
+  ENDSUBROUTINE READ_UNDELIMITED
+
+   SUBROUTINE WRITE_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG)
+   !< FORMATTED OUTPUT.
+   CLASS(STRING),             INTENT(IN)    :: DTV       !< THE STRING.
+   INTEGER,                   INTENT(IN)    :: UNIT      !< LOGICAL UNIT.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)    :: IOTYPE    !< EDIT DESCRIPTOR.
+   INTEGER,                   INTENT(IN)    :: V_LIST(:) !< EDIT DESCRIPTOR LIST.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT    !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG     !< IO STATUS MESSAGE.
+
+   IF (ALLOCATED(DTV%RAW)) THEN
+     WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW
+   ELSE
+     WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)''
+   ENDIF
+   ENDSUBROUTINE WRITE_FORMATTED
+
+   SUBROUTINE READ_UNFORMATTED(DTV, UNIT, IOSTAT, IOMSG)
+   !< UNFORMATTED INPUT.
+   !<
+   !< @BUG CHANGE TEMPORARY ACKS: FIND A MORE PRECISE LENGTH OF THE INPUT STRING AND AVOID THE TRIMMING!
+   CLASS(STRING),             INTENT(INOUT) :: DTV       !< THE STRING.
+   INTEGER,                   INTENT(IN)    :: UNIT      !< LOGICAL UNIT.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT    !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG     !< IO STATUS MESSAGE.
+   CHARACTER(KIND=CK, LEN=100)              :: TEMPORARY !< TEMPORARY STORAGE STRING.
+
+   READ(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)TEMPORARY
+   DTV%RAW = TRIM(TEMPORARY)
+   ENDSUBROUTINE READ_UNFORMATTED
+
+   SUBROUTINE WRITE_UNFORMATTED(DTV, UNIT, IOSTAT, IOMSG)
+   !< UNFORMATTED OUTPUT.
+   CLASS(STRING),             INTENT(IN)    :: DTV    !< THE STRING.
+   INTEGER,                   INTENT(IN)    :: UNIT   !< LOGICAL UNIT.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG  !< IO STATUS MESSAGE.
+
+   IF (ALLOCATED(DTV%RAW)) THEN
+     WRITE(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW
+   ELSE
+     WRITE(UNIT, IOSTAT=IOSTAT, IOMSG=IOMSG)''
+   ENDIF
+   ENDSUBROUTINE WRITE_UNFORMATTED
+
+   ! MISCELLANEA
+   ELEMENTAL FUNCTION REPLACE_ONE_OCCURRENCE(SELF, OLD, NEW) RESULT(REPLACED)
+   !< RETURN A STRING WITH THE FIRST OCCURRENCE OF SUBSTRING OLD REPLACED BY NEW.
+   !<
+   !< @NOTE THE DOCTEST IS NOT NECESSARY, THIS BEING TESTED BY [[STRING:REPLACE]].
+   CLASS(STRING),             INTENT(IN)  :: SELF      !< THE STRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: OLD       !< OLD SUBSTRING.
+   CHARACTER(KIND=CK, LEN=*), INTENT(IN)  :: NEW       !< NEW SUBSTRING.
+   TYPE(STRING)                           :: REPLACED  !< THE STRING WITH OLD REPLACED BY NEW.
+   INTEGER                                :: POS       !< POSITION FROM WHICH REPLACE OLD.
+
+   IF (ALLOCATED(SELF%RAW)) THEN
+      REPLACED = SELF
+      POS = INDEX(STRING=SELF%RAW, SUBSTRING=OLD)
+      IF (POS>0) THEN
+         IF (POS==1) THEN
+            REPLACED%RAW = NEW//SELF%RAW(LEN(OLD)+1:)
+         ELSE
+            REPLACED%RAW = SELF%RAW(1:POS-1)//NEW//SELF%RAW(POS+LEN(OLD):)
+         ENDIF
+      ENDIF
+   ENDIF
+   ENDFUNCTION REPLACE_ONE_OCCURRENCE
+
+   ! NON TYPE-BOUND-PROCEDURES
+   SUBROUTINE GET_DELIMITER_MODE(UNIT, DELIM, IOSTAT, IOMSG)
+   !< GET THE DELIM CHANGEABLE CONNECTION MODE FOR THE GIVEN UNIT.
+   !<
+   !< IF THE UNIT IS CONNECTED TO AN INTERNAL FILE, THEN THE DEFAULT VALUE OF NONE IS ALWAYS RETURNED.
+   USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_INQUIRE_INTERNAL_UNIT
+   INTEGER,                   INTENT(IN)    :: UNIT         !< THE UNIT FOR THE CONNECTION.
+   CHARACTER(LEN=1, KIND=CK), INTENT(OUT)   :: DELIM        !< REPRESENTS THE VALUE OF THE DELIM MODE.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT       !< IOSTAT ERROR CODE, NON-ZERO ON ERROR.
+   CHARACTER(*),              INTENT(INOUT) :: IOMSG        !< IOMSG EXPLANATORY MESSAGE - ONLY DEFINED IF IOSTAT IS NON-ZERO.
+   CHARACTER(10)                            :: DELIM_BUFFER !< BUFFER FOR INQUIRE ABOUT DELIM, SIZED FOR APOSTROHPE.
+   CHARACTER(LEN(IOMSG))                    :: LOCAL_IOMSG  !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED.
+
+   ! GET THE STRING REPRESENTATION OF THE CHANGEABLE MODE
+   INQUIRE(UNIT, DELIM=DELIM_BUFFER, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG)
+   IF (IOSTAT == IOSTAT_INQUIRE_INTERNAL_UNIT) THEN
+      ! NO WAY OF DETERMINING THE DELIM MODE FOR AN INTERNAL FILE
+      IOSTAT = 0
+      DELIM = ''
+      RETURN
+   ELSEIF (IOSTAT /= 0) THEN
+      IOMSG = LOCAL_IOMSG
+      RETURN
+   ENDIF
+   ! INTERPRET THE DELIM STRING
+   IF (DELIM_BUFFER == 'QUOTE') THEN
+      DELIM = '"'
+   ELSEIF (DELIM_BUFFER == 'APOSTROPHE') THEN
+      DELIM = ''''
+   ELSE
+      DELIM = '"'
+   ENDIF
+   ENDSUBROUTINE GET_DELIMITER_MODE
+
+   SUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD(UNIT, CH, IOSTAT, IOMSG)
+   !< GET THE NEXT NON-BLANK CHARACTER IN THE CURRENT RECORD.
+   INTEGER,                   INTENT(IN)    :: UNIT   !< LOGICAL UNIT.
+   CHARACTER(KIND=CK, LEN=1), INTENT(OUT)   :: CH     !< THE NON-BLANK CHARACTER READ. NOT VALID IF IOSTAT IS NON-ZERO.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG  !< IO STATUS MESSAGE.
+
+   DO
+      ! WE SPCIFY NON-ADVANCING, JUST IN CASE WE WANT THIS CALLABLE OUTSIDE THE CONTEXT OF A CHILD INPUT STATEMENT
+      ! THE PAD SPECIFIER SIMPLY SAVES THE NEED FOR THE READ STATEMENT TO DEFINE CH IF EOR IS HIT
+      ! READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG, ADVANCE='NO') CH
+      ! ...BUT THAT CAUSES IFORT TO BLOW UP AT RUNTIME
+      READ(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG, PAD='NO') CH
+      IF (IOSTAT /= 0) RETURN
+      IF (CH /= '') EXIT
+   ENDDO
+   ENDSUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD
+
+   SUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT, CH, IOSTAT, IOMSG)
+   !< GET THE NEXT NON-BLANK CHARACTER, ADVANCING RECORDS IF NECESSARY.
+   INTEGER,                   INTENT(IN)    :: UNIT        !< LOGICAL UNIT.
+   CHARACTER(KIND=CK, LEN=1), INTENT(OUT)   :: CH          !< THE NON-BLANK CHARACTER READ. NOT VALID IF IOSTAT IS NON-ZERO.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT      !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG       !< IO STATUS MESSAGE.
+   CHARACTER(LEN(IOMSG))                    :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED.
+
+   DO
+      CALL GET_NEXT_NON_BLANK_CHARACTER_THIS_RECORD(UNIT=UNIT, CH=CH, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG)
+      IF (IS_IOSTAT_EOR(IOSTAT)) THEN
+         ! TRY AGAIN ON THE NEXT RECORD
+         READ (UNIT, "(/)", IOSTAT=IOSTAT, IOMSG=IOMSG)
+         IF (IOSTAT /= 0) RETURN
+      ELSEIF (IOSTAT /= 0) THEN
+         ! SOME SORT OF PROBLEM
+         IOMSG = LOCAL_IOMSG
+         RETURN
+      ELSE
+         ! GOT IT
+         EXIT
+      ENDIF
+   ENDDO
+   ENDSUBROUTINE GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD
+
+   SUBROUTINE GET_DECIMAL_MODE(UNIT, DECIMAL_POINT, IOSTAT, IOMSG)
+   !< GET THE DECIMAL CHANGEABLE CONNECTION MODE FOR THE GIVEN UNIT.
+   !<
+   !< IF THE UNIT IS CONNECTED TO AN INTERNAL FILE, THEN THE DEFAULT VALUE OF DECIMAL IS ALWAYS RETURNED. THIS MAY NOT BE THE
+   !< ACTUAL VALUE IN FORCE AT THE TIME OF THE CALL TO THIS PROCEDURE.
+   USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_INQUIRE_INTERNAL_UNIT
+   INTEGER,                   INTENT(IN)    :: UNIT           !< LOGICAL UNIT.
+   LOGICAL,                   INTENT(OUT)   :: DECIMAL_POINT  !< TRUE IF THE DECIMAL MODE IS POINT, FALSE OTHERWISE.
+   INTEGER,                   INTENT(OUT)   :: IOSTAT         !< IO STATUS CODE.
+   CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG          !< IO STATUS MESSAGE.
+   CHARACTER(5)                             :: DECIMAL_BUFFER !< BUFFER FOR INQUIRE ABOUT DECIMAL, SIZED FOR POINT OR COMMA.
+   CHARACTER(LEN(IOMSG))                    :: LOCAL_IOMSG    !< LOCAL IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED.
+
+   INQUIRE(UNIT, DECIMAL=DECIMAL_BUFFER, IOSTAT=IOSTAT, IOMSG=LOCAL_IOMSG)
+   IF (IOSTAT == IOSTAT_INQUIRE_INTERNAL_UNIT) THEN
+      ! NO WAY OF DETERMINING THE DECIMAL MODE FOR AN INTERNAL FILE
+      IOSTAT = 0
+      DECIMAL_POINT = .TRUE.
+      RETURN
+   ELSE IF (IOSTAT /= 0) THEN
+      IOMSG = LOCAL_IOMSG
+      RETURN
+   ENDIF
+   DECIMAL_POINT = DECIMAL_BUFFER == 'POINT'
+   ENDSUBROUTINE GET_DECIMAL_MODE
+ENDMODULE STRINGIFOR_STRING_T
+
+
+
+
+!< STRINGIFOR, STRINGS FORTRAN MANIPULATOR WITH STEROIDS.
+
+MODULE STRINGIFOR
+!< STRINGIFOR, STRINGS FORTRAN MANIPULATOR WITH STEROIDS.
+USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P
+! USE STRINGIFOR_STRING_T, ONLY : ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY, CK, STRING
+USE STRINGIFOR_STRING_T, ONLY : ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY, CK, GLOB, STRING, STRJOIN
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+! EXPOSE STINGIFOR OBJECTS
+PUBLIC :: CK
+PUBLIC :: GLOB
+PUBLIC :: STRJOIN
+PUBLIC :: STRING
+! EXPOSE STINGIFOR OVERLOADED BUILTINS AND OPERATORS
+! PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY
+PUBLIC :: ADJUSTL, ADJUSTR, COUNT, INDEX, LEN_TRIM, REPEAT, SCAN, TRIM, VERIFY
+! EXPOSE STINGIFOR NEW PROCEDURES
+PUBLIC :: READ_FILE, READ_LINES, WRITE_FILE, WRITE_LINES
+! EXPOSE PENF KINDS
+PUBLIC :: I1P, I2P, I4P, I8P, R4P, R8P, R16P
+
+CONTAINS
+   SUBROUTINE READ_FILE(FILE, LINES, FORM, IOSTAT, IOMSG)
+   !< READ A FILE AS A SINGLE STRING STREAM.
+   !<
+   !< THE LINES ARE RETURNED AS AN ARRAY OF STRINGS THAT ARE READ UNTIL THE EOF IS REACHED.
+   !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< TYPE(STRING)              :: LINE(3)
+   !< INTEGER                   :: IOSTAT
+   !< CHARACTER(LEN=99)         :: IOMSG
+   !< INTEGER                   :: SCRATCH
+   !< INTEGER                   :: L
+   !< LOGICAL                   :: TEST_PASSED(8)
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP')
+   !< WRITE(SCRATCH, "(A)") LINE(1)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(2)%CHARS()
+   !< WRITE(SCRATCH, "(A)") LINE(3)%CHARS()
+   !< CLOSE(SCRATCH)
+   !< CALL READ_FILE(FILE='READ_FILE_TEST.TMP', LINES=STRINGS, IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+1) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< WRITE(SCRATCH) LINE(1)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(2)%CHARS()//NEW_LINE('A')
+   !< WRITE(SCRATCH) LINE(3)%CHARS()//NEW_LINE('A')
+   !< CLOSE(SCRATCH)
+   !< CALL READ_FILE(FILE='READ_FILE_TEST.TMP', LINES=STRINGS, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+5) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='READ_FILE_TEST.TMP', FORM='UNFORMATTED', ACCESS='STREAM')
+   !< CLOSE(SCRATCH, STATUS='DELETE')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(LEN=*), INTENT(IN)               :: FILE       !< FILE NAME.
+   TYPE(STRING),     INTENT(OUT), ALLOCATABLE :: LINES(:)   !< THE LINES.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL  :: FORM       !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL  :: IOSTAT     !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL  :: IOMSG      !< IO STATUS MESSAGE.
+   TYPE(STRING)                               :: FORM_      !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                    :: IOSTAT_    !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE              :: IOMSG_     !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   INTEGER                                    :: UNIT       !< LOGICAL UNIT.
+   LOGICAL                                    :: DOES_EXIST !< CHECK IF FILE EXIST.
+
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   INQUIRE(FILE=FILE, IOMSG=IOMSG_, IOSTAT=IOSTAT_, EXIST=DOES_EXIST)
+   IF (DOES_EXIST) THEN
+      FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+      SELECT CASE(FORM_%CHARS())
+      CASE('FORMATTED')
+         OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+      CASE('UNFORMATTED')
+         OPEN(NEWUNIT=UNIT, FILE=FILE, STATUS='OLD', ACTION='READ', FORM='UNFORMATTED', ACCESS='STREAM', &
+              IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+      ENDSELECT
+      CALL READ_LINES(UNIT=UNIT, LINES=LINES, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_)
+      10 CLOSE(UNIT)
+   ENDIF
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE READ_FILE
+
+   SUBROUTINE READ_LINES(UNIT, LINES, FORM, IOSTAT, IOMSG)
+   !< READ LINES (RECORDS) FROM A CONNECTED-FORMATTED UNIT.
+   !<
+   !< @NOTE THE CONNECTED UNIT IS REWINDED. AT A SUCCESSFUL EXIT CURRENT RECORD IS AT EOF, AT THE BEGINNING OTHERWISE.
+   !<
+   !< THE LINES ARE RETURNED AS AN ARRAY OF STRINGS THAT ARE READ UNTIL THE EOF IS REACHED.
+   !< THE LINE IS READ AS AN ASCII STREAM READ UNTIL THE EOR IS REACHED.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[READ_FILE]] DOCTESTS.
+   INTEGER,          INTENT(IN)               :: UNIT     !< LOGICAL UNIT.
+   TYPE(STRING),     INTENT(OUT), ALLOCATABLE :: LINES(:) !< THE LINES.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL  :: FORM     !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL  :: IOSTAT   !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL  :: IOMSG    !< IO STATUS MESSAGE.
+   TYPE(STRING)                               :: FORM_    !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                    :: IOSTAT_  !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE              :: IOMSG_   !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   CHARACTER(KIND=CK, LEN=1)                  :: CH       !< CHARACTER STORAGE.
+   INTEGER                                    :: L        !< COUNTER.
+
+   FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   REWIND(UNIT)
+   SELECT CASE(FORM_%CHARS())
+   CASE('FORMATTED')
+      L = 0
+      DO
+         READ(UNIT, *, ERR=10, END=10)
+         L = L + 1
+      ENDDO
+   CASE('UNFORMATTED')
+      L = 0
+      DO
+         READ(UNIT, ERR=10, END=10) CH
+         IF (CH==NEW_LINE('A')) L = L + 1
+      ENDDO
+   ENDSELECT
+   10 REWIND(UNIT)
+   IF (L>0) THEN
+      ALLOCATE(LINES(1:L))
+      L = 1
+      IOSTAT_ = 0
+      DO
+         CALL LINES(L)%READ_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT_, IOMSG=IOMSG_)
+         IF ((IOSTAT_/=0.AND..NOT.IS_IOSTAT_EOR(IOSTAT_)).OR.(L>=SIZE(LINES, DIM=1))) THEN
+            EXIT
+         ENDIF
+         L = L + 1
+      ENDDO
+   ENDIF
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE READ_LINES
+
+   SUBROUTINE WRITE_FILE(FILE, LINES, FORM, IOSTAT, IOMSG)
+   !< WRITE A SINGLE STRING STREAM INTO FILE.
+   !<
+   !< @NOTE FOR UNFORMATTED READ ONLY `ACCESS='STREAM'` IS SUPPORTED WITH NEW_LINE AS LINE TERMINATOR.
+   !<
+   !<```FORTRAN
+   !< TYPE(STRING)              :: ASTRING
+   !< TYPE(STRING)              :: ANOTHERSTRING
+   !< TYPE(STRING), ALLOCATABLE :: STRINGS(:)
+   !< TYPE(STRING)              :: LINE(3)
+   !< INTEGER                   :: IOSTAT
+   !< CHARACTER(LEN=99)         :: IOMSG
+   !< INTEGER                   :: SCRATCH
+   !< INTEGER                   :: L
+   !< LOGICAL                   :: TEST_PASSED(8)
+   !< LINE(1) = ' HELLO WORLD!   '
+   !< LINE(2) = 'HOW ARE YOU?  '
+   !< LINE(3) = '   ALL SAY: "FINE THANKS"'
+   !< ANOTHERSTRING = ANOTHERSTRING%JOIN(ARRAY=LINE, SEP=NEW_LINE('A'))
+   !< CALL WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', LINES=LINE, IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(1) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+1) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< CALL WRITE_FILE(FILE='WRITE_FILE_TEST.TMP', LINES=LINE, FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%READ_FILE(FILE='WRITE_FILE_TEST.TMP', FORM='UNFORMATTED', IOSTAT=IOSTAT, IOMSG=IOMSG)
+   !< CALL ASTRING%SPLIT(TOKENS=STRINGS, SEP=NEW_LINE('A'))
+   !< TEST_PASSED(5) = (SIZE(STRINGS, DIM=1)==SIZE(LINE, DIM=1))
+   !< DO L=1, SIZE(STRINGS, DIM=1)
+   !<   TEST_PASSED(L+5) = (STRINGS(L)==LINE(L))
+   !< ENDDO
+   !< OPEN(NEWUNIT=SCRATCH, FILE='WRITE_FILE_TEST.TMP')
+   !< CLOSE(SCRATCH, STATUS='DELETE')
+   !< PRINT '(L1)', ALL(TEST_PASSED)
+   !<```
+   !=> T <<<
+   CHARACTER(LEN=*), INTENT(IN)              :: FILE      !< FILE NAME.
+   TYPE(STRING),     INTENT(IN)              :: LINES(1:) !< THE LINES.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM      !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT    !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG     !< IO STATUS MESSAGE.
+   TYPE(STRING)                              :: FORM_     !< FORMAT OF UNIT, LOCAL VARIABLE.
+   INTEGER                                   :: IOSTAT_   !< IO STATUS CODE, LOCAL VARIABLE.
+   CHARACTER(LEN=:), ALLOCATABLE             :: IOMSG_    !< IO STATUS MESSAGE, LOCAL VARIABLE.
+   INTEGER                                   :: UNIT      !< LOGICAL UNIT.
+
+   IOMSG_ = REPEAT(' ', 99) ; IF (PRESENT(IOMSG)) IOMSG_ = IOMSG
+   FORM_ = 'FORMATTED' ; IF (PRESENT(FORM)) FORM_ = FORM ; FORM_ = FORM_%UPPER()
+   SELECT CASE(FORM_%CHARS())
+   CASE('FORMATTED')
+      OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+   CASE('UNFORMATTED')
+      OPEN(NEWUNIT=UNIT, FILE=FILE, ACTION='WRITE', FORM='UNFORMATTED', ACCESS='STREAM', IOMSG=IOMSG_, IOSTAT=IOSTAT_, ERR=10)
+   ENDSELECT
+   CALL WRITE_LINES(UNIT=UNIT, LINES=LINES, FORM=FORM, IOMSG=IOMSG_, IOSTAT=IOSTAT_)
+   10 CLOSE(UNIT)
+   IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+   IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+   ENDSUBROUTINE WRITE_FILE
+
+   SUBROUTINE WRITE_LINES(UNIT, LINES, FORM, IOSTAT, IOMSG)
+   !< WRITE LINES (RECORDS) TO A CONNECTED-FORMATTED UNIT.
+   !<
+   !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[WRITE_FILE]] DOCTESTS.
+   INTEGER,          INTENT(IN)              :: UNIT      !< LOGICAL UNIT.
+   TYPE(STRING),     INTENT(IN)              :: LINES(1:) !< THE LINES.
+   CHARACTER(LEN=*), INTENT(IN),    OPTIONAL :: FORM      !< FORMAT OF UNIT.
+   INTEGER,          INTENT(OUT),   OPTIONAL :: IOSTAT    !< IO STATUS CODE.
+   CHARACTER(LEN=*), INTENT(INOUT), OPTIONAL :: IOMSG     !< IO STATUS MESSAGE.
+   INTEGER                                   :: L         !< COUNTER.
+
+   DO L=1, SIZE(LINES, DIM=1)
+      CALL LINES(L)%WRITE_LINE(UNIT=UNIT, FORM=FORM, IOSTAT=IOSTAT, IOMSG=IOMSG)
+   ENDDO
+   ENDSUBROUTINE WRITE_LINES
+ENDMODULE STRINGIFOR
+
+
+
+
+
+!< FOXY XML TAG CLASS.
+MODULE FOXY_XML_TAG
+!< FOXY XML TAG CLASS.
+USE PENF
+USE STRINGIFOR
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_TAG
+
+TYPE :: XML_TAG
+  !< XML TAG CLASS.
+  !<
+  !< A VALID XML TAG MUST HAVE THE FOLLOWING SYNTAX FOR A TAG WITHOUT A CONTENT (WITH ONLY ATTRIBUTES):
+  !<```XML
+  !<   <TAG_NAME ATT#1_NAME="ATT#1_VAL" ATT#2_NAME="ATT#2_VAL"... ATT#NT_NAME="ATT#NT_VAL"/>
+  !<```
+  !< WHILE A TAG WITH A CONTENT MUST HAVE THE FOLLOWING SYNTAX:
+  !<```XML
+  !<   <TAG_NAME ATT#1_NAME="ATT#1_VAL" ATT#2_NAME="ATT#2_VAL"... ATT#NT_NAME="ATT#NT_VAL">TAG_CONTENT</TAG_NAME>
+  !<```
+  !<
+  !< IT IS WORTH NOTING THAT THE SYNTAX IS CASE SENSITIVE AND THAT THE ATTRIBUTES ARE OPTIONAL. EACH ATTRIBUTE NAME MUST BE FOLLOWED
+  !< BY '="' WITHOUT ANY ADDITIONAL WHITE SPACES AND ITS VALUE MUST BE TERMINED BY '"'. EACH ATTRIBUTE IS SEPARATED BY ONE OR MORE
+  !< WHITE SPACES.
+  PRIVATE
+  TYPE(STRING)              :: TAG_NAME                !< TAG NAME.
+  TYPE(STRING)              :: TAG_CONTENT             !< TAG CONTENT.
+  TYPE(STRING), ALLOCATABLE :: ATTRIBUTE(:,:)          !< ATTRIBUTES NAMES/VALUES PAIRS, [1:2, 1:].
+  INTEGER(I4P)              :: ATTRIBUTES_NUMBER=0     !< NUMBER OF DEFINED ATTRIBUTES.
+  INTEGER(I4P)              :: INDENT=0                !< NUMBER OF INDENT-WHITE-SPACES.
+  LOGICAL                   :: IS_SELF_CLOSING=.FALSE. !< SELF CLOSING TAG FLAG.
+  CONTAINS
+    ! PUBLIC METHODS
+    GENERIC               :: ADD_ATTRIBUTES =>        &
+                             ADD_SINGLE_ATTRIBUTE,    &
+                             ADD_MULTIPLE_ATTRIBUTES, &
+                             ADD_STREAM_ATTRIBUTES       !< ADD ATTRIBUTES NAME/VALUE PAIRS.
+    PROCEDURE, PASS(SELF) :: ATTRIBUTES                  !< RETURN ATTRIBUTES NAME/VALUE PAIRS AS STRING.
+    PROCEDURE, PASS(SELF) :: GET_CONTENT                 !< RETURN TAG CONTENT.
+    GENERIC               :: DELETE_ATTRIBUTES =>     &
+                             DELETE_SINGLE_ATTRIBUTE, &
+                             DELETE_MULTIPLE_ATTRIBUTES  !< DELETE ATTRIBUTES NAME/VALUE PAIRS.
+    PROCEDURE, PASS(SELF) :: DELETE_CONTENT              !< DELETE TAG CONENT.
+    PROCEDURE, PASS(SELF) :: END_TAG                     !< RETURN `</TAG_NAME>` END TAG.
+    PROCEDURE, PASS(SELF) :: FREE                        !< FREE DYNAMIC MEMORY.
+    PROCEDURE, PASS(SELF) :: IS_ATTRIBUTE_PRESENT        !< RETURN .TRUE. IT THE QUERIED ATTRIBUTE NAME IS DEFINED.
+    PROCEDURE, PASS(SELF) :: IS_PARSED                   !< CHECK IS TAG IS CORRECTLY PARSED, I.E. ITS *TAG_NAME* IS ALLOCATED.
+    PROCEDURE, PASS(SELF) :: NAME                        !< RETURN TAG NAME.
+    PROCEDURE, PASS(SELF) :: PARSE                       !< PARSE THE TAG CONTAINED INTO A SOURCE STRING.
+    PROCEDURE, PASS(SELF) :: SELF_CLOSING_TAG            !< RETURN `<TAG_NAME.../>` SELF CLOSING TAG.
+    PROCEDURE, PASS(SELF) :: SET                         !< SET TAG DATA.
+    PROCEDURE, PASS(SELF) :: START_TAG                   !< RETURN `<TAG_NAME...>` START TAG.
+    PROCEDURE, PASS(SELF) :: STRINGIFY                   !< CONVERT THE WHOLE TAG INTO A STRING.
+    PROCEDURE, PASS(SELF) :: WRITE => WRITE_TAG          !< WRITE TAG TO UNIT FILE.
+    GENERIC               :: ASSIGNMENT(=) => ASSIGN_TAG !< ASSIGNMENT OPERATOR OVERLOADING.
+    ! PRIVATE METHODS
+    PROCEDURE, PASS(SELF), PRIVATE :: ADD_SINGLE_ATTRIBUTE       !< ADD ONE ATTRIBUTE NAME/VALUE PAIR.
+    PROCEDURE, PASS(SELF), PRIVATE :: ADD_MULTIPLE_ATTRIBUTES    !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS.
+    PROCEDURE, PASS(SELF), PRIVATE :: ADD_STREAM_ATTRIBUTES      !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS PASSED AS STREAM.
+    PROCEDURE, PASS(SELF), PRIVATE :: ALLOC_ATTRIBUTES           !< ALLOCATE (PREPARE FOR FILLING) DYNAMIC MEMORY OF ATTRIBUTES.
+    PROCEDURE, PASS(SELF), PRIVATE :: DELETE_SINGLE_ATTRIBUTE    !< DELETE ONE ATTRIBUTE NAME/VALUE PAIR.
+    PROCEDURE, PASS(SELF), PRIVATE :: DELETE_MULTIPLE_ATTRIBUTES !< DELETE LIST OF ATTRIBUTES NAME/VALUE PAIRS.
+    PROCEDURE, PASS(SELF), PRIVATE :: GET                        !< GET THE TAG VALUE AND ATTRIBUTES FROM SOURCE.
+    PROCEDURE, PASS(SELF), PRIVATE :: GET_VALUE                  !< GET THE TAG VALUE FROM SOURCE AFTER TAG_NAME HAS BEEN SET.
+    PROCEDURE, PASS(SELF), PRIVATE :: GET_ATTRIBUTES             !< GET THE ATTRIBUTES VALUES FROM SOURCE.
+    PROCEDURE, PASS(SELF), PRIVATE :: PARSE_TAG_NAME             !< PARSE THE TAG NAME CONTAINED INTO A STRING.
+    PROCEDURE, PASS(SELF), PRIVATE :: PARSE_ATTRIBUTES_NAMES     !< PARSE THE TAG ATTRIBUTES NAMES CONTAINED INTO A STRING.
+    PROCEDURE, PASS(SELF), PRIVATE :: SEARCH                     !< SEARCH TAG NAMED *TAG_NAME* INTO A STRING.
+    ! OPERATORS
+    PROCEDURE, PASS(LHS), PRIVATE :: ASSIGN_TAG !< ASSIGNMENT BETWEEN TWO TAGS.
+#if (__GNUC__ < 9)
+    FINAL                         :: FINALIZE   !< FREE DYNAMIC MEMORY WHEN FINALIZING.
+#endif
+ENDTYPE XML_TAG
+
+INTERFACE XML_TAG
+  !< OVERLOAD *XML_TAG* WITH CREATOR PROCEDURES.
+  MODULE PROCEDURE CREATE_TAG_FLAT, CREATE_TAG_NESTED
+ENDINTERFACE
+CONTAINS
+  ! CREATOR PROCEDURES OVERLOADING *XML_TAG* NAME
+  PURE FUNCTION CREATE_TAG_FLAT(NAME, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, CONTENT, INDENT, &
+                                IS_CONTENT_INDENTED, IS_SELF_CLOSING) RESULT(TAG)
+  !< RETURN AN INSTANCE OF XML TAG.
+  !<
+  !< ATTRIBUTES ARE PASSED BY ARRAY.
+  CHARACTER(*), INTENT(IN)           :: NAME                      !< TAG NAME.
+  CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTE(1:)             !< ATTRIBUTE NAME/VALUE PAIR [1:2].
+  CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:)         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:].
+  CHARACTER(*), INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM.
+  LOGICAL,      INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE.
+  CHARACTER(*), INTENT(IN), OPTIONAL :: CONTENT                   !< TAG VALUE.
+  INTEGER(I4P), INTENT(IN), OPTIONAL :: INDENT                    !< NUMBER OF INDENT-WHITE-SPACES.
+  LOGICAL,      INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED       !< ACTIVATE CONTENT INDENTATION.
+  LOGICAL,      INTENT(IN), OPTIONAL :: IS_SELF_CLOSING           !< THE TAG IS SELF CLOSING.
+  TYPE(XML_TAG)                      :: TAG                       !< XML TAG.
+
+  CALL TAG%SET(NAME=NAME, ATTRIBUTE=ATTRIBUTE, ATTRIBUTES=ATTRIBUTES, ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, &
+               SANITIZE_ATTRIBUTES_VALUE=SANITIZE_ATTRIBUTES_VALUE, CONTENT=CONTENT,                       &
+               INDENT=INDENT, IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, IS_SELF_CLOSING=IS_SELF_CLOSING)
+  ENDFUNCTION CREATE_TAG_FLAT
+
+  PURE FUNCTION CREATE_TAG_NESTED(NAME, CONTENT, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, INDENT, &
+                                  IS_CONTENT_INDENTED) RESULT(TAG)
+  !< RETURN AN INSTANCE OF XML TAG WITH VALUE BEING A NESTED TAG.
+  !<
+  !< ATTRIBUTES ARE PASSED BY ARRAY.
+  CHARACTER(*),  INTENT(IN)           :: NAME                      !< TAG NAME.
+  TYPE(XML_TAG), INTENT(IN)           :: CONTENT                   !< TAG VALUE AS NESTED TAG..
+  CHARACTER(*),  INTENT(IN), OPTIONAL :: ATTRIBUTE(1:)             !< ATTRIBUTE NAME/VALUE PAIR [1:2].
+  CHARACTER(*),  INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:)         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:].
+  CHARACTER(*),  INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM.
+  LOGICAL,       INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE.
+  INTEGER(I4P),  INTENT(IN), OPTIONAL :: INDENT                    !< NUMBER OF INDENT-WHITE-SPACES.
+  LOGICAL,       INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED       !< ACTIVATE VALUE INDENTATION.
+  TYPE(XML_TAG)                       :: TAG                       !< XML TAG.
+
+  CALL TAG%SET(NAME=NAME, ATTRIBUTE=ATTRIBUTE, ATTRIBUTES=ATTRIBUTES, CONTENT=CONTENT%STRINGIFY(),                      &
+               SANITIZE_ATTRIBUTES_VALUE=SANITIZE_ATTRIBUTES_VALUE, ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, INDENT=INDENT, &
+               IS_CONTENT_INDENTED=IS_CONTENT_INDENTED)
+  ENDFUNCTION CREATE_TAG_NESTED
+
+  ! PUBLIC METHODS
+  PURE FUNCTION ATTRIBUTES(SELF) RESULT(ATT_)
+  !< RETURN ATTRIBUTES NAME/VALUE PAIRS AS STRING.
+  CLASS(XML_TAG), INTENT(IN)    :: SELF !< XML TAG.
+  CHARACTER(LEN=:), ALLOCATABLE :: ATT_ !< THE ATTRIBUTES STRING.
+  INTEGER(I4P)                  :: A    !< COUNTER.
+
+  IF (SELF%ATTRIBUTES_NUMBER>0) THEN
+    ATT_ = ''
+    DO A=1, SELF%ATTRIBUTES_NUMBER
+      ATT_ = ATT_//' '//SELF%ATTRIBUTE(1, A)//'="'//SELF%ATTRIBUTE(2, A)//'"'
+    ENDDO
+    ATT_ = TRIM(ADJUSTL(ATT_))
+  ENDIF
+  ENDFUNCTION ATTRIBUTES
+
+  PURE SUBROUTINE GET_CONTENT(SELF, NAME, CONTENT)
+  !< RETURN TAG CONTENT OF SELF (OR ITS NESTED TAGS) IF NAMED *NAME*.
+  !<
+  !< @NOTE IF THERE IS NO VALUE, THE *CONTENT* STRING IS RETURNED DEALLOCATED.
+  CLASS(XML_TAG),                INTENT(IN)  :: SELF    !< XML TAG.
+  CHARACTER(*),                  INTENT(IN)  :: NAME    !< SEARCHED TAG NAME.
+  CHARACTER(LEN=:), ALLOCATABLE, INTENT(OUT) :: CONTENT !< TAG CONTENT.
+  TYPE(XML_TAG)                              :: TAG     !< DUMMY XML TAG.
+
+  IF (ALLOCATED(CONTENT)) DEALLOCATE(CONTENT)
+  IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN
+    IF (SELF%TAG_NAME==NAME) THEN
+      IF (SELF%TAG_CONTENT%IS_ALLOCATED()) CONTENT = SELF%TAG_CONTENT%CHARS()
+    ELSE
+      IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN
+        CALL TAG%SEARCH(TAG_NAME=NAME, SOURCE=SELF%TAG_CONTENT%CHARS())
+        IF (TAG%TAG_CONTENT%IS_ALLOCATED()) CONTENT = TAG%TAG_CONTENT%CHARS()
+      ENDIF
+    ENDIF
+  ENDIF
+  ENDSUBROUTINE GET_CONTENT
+
+  PURE FUNCTION END_TAG(SELF, IS_INDENTED) RESULT(TAG_)
+  !< RETURN `</TAG_NAME>` END TAG.
+  CLASS(XML_TAG), INTENT(IN)           :: SELF        !< XML TAG.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_INDENTED !< ACTIVATE CONTENT INDENTATION.
+  CHARACTER(LEN=:), ALLOCATABLE        :: TAG_        !< THE END TAG STRING.
+
+  TAG_ = '</'//SELF%TAG_NAME//'>'
+  IF (PRESENT(IS_INDENTED)) THEN
+    IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_
+  ENDIF
+  ENDFUNCTION END_TAG
+
+  ELEMENTAL SUBROUTINE FREE(SELF)
+  !< FREE DYNAMIC MEMORY.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG.
+
+  CALL SELF%TAG_NAME%FREE
+  CALL SELF%TAG_CONTENT%FREE
+  IF (ALLOCATED(SELF%ATTRIBUTE)) THEN
+    CALL SELF%ATTRIBUTE%FREE
+    DEALLOCATE(SELF%ATTRIBUTE)
+  ENDIF
+  SELF%ATTRIBUTES_NUMBER = 0
+  SELF%INDENT = 0
+  SELF%IS_SELF_CLOSING = .FALSE.
+  ENDSUBROUTINE FREE
+
+  ELEMENTAL FUNCTION IS_PARSED(SELF)
+  !< CHECK IS TAG IS CORRECTLY PARSED, I.E. ITS *TAG_NAME* IS ALLOCATED.
+  CLASS(XML_TAG), INTENT(IN) :: SELF      !< XML TAG.
+  LOGICAL                    :: IS_PARSED !< RESULT OF CHECK.
+
+  IS_PARSED = SELF%TAG_NAME%IS_ALLOCATED()
+  ENDFUNCTION IS_PARSED
+
+  PURE FUNCTION NAME(SELF)
+  !< RETURN TAG NAME.
+  CLASS(XML_TAG), INTENT(IN)    :: SELF !< XML TAG.
+  CHARACTER(LEN=:), ALLOCATABLE :: NAME !< XML TAG NAME.
+
+  NAME = SELF%TAG_NAME%CHARS()
+  ENDFUNCTION NAME
+
+  ELEMENTAL SUBROUTINE PARSE(SELF, SOURCE, TSTART, TEND)
+  !< PARSE THE TAG CONTAINED INTO A SOURCE STRING.
+  !<
+  !< IT IS ASSUMED THAT THE FIRST TAG CONTAINED INTO THE SOURCE STRING IS PARSED, THE OTHERS EVENTUALLY PRESENT ARE OMITTED.
+  !< VALID SYNTAX ARE:
+  !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL"...>...</TAG_NAME>`
+  !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL".../>`
+  !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED.
+  CLASS(XML_TAG),         INTENT(INOUT) :: SELF      !< XML TAG.
+  CHARACTER(*),           INTENT(IN)    :: SOURCE    !< STRING CONTAINING THE INPUT.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TSTART    !< STARTING INDEX OF TAG INSIDE THE STRING.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TEND      !< ENDING INDEX OF TAG INSIDE THE STRING.
+  INTEGER(I4P)                          :: TSTARTD   !< STARTING INDEX OF TAG INSIDE THE STRING.
+  INTEGER(I4P)                          :: TENDD     !< ENDING INDEX OF TAG INSIDE THE STRING.
+
+  TSTARTD = 0
+  TENDD   = 0
+  CALL SELF%PARSE_TAG_NAME(SOURCE=SOURCE, TSTART=TSTARTD, TEND=TENDD)
+  IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN
+    IF (INDEX(STRING=SOURCE(TSTARTD:TENDD), SUBSTRING='=')>0) CALL SELF%PARSE_ATTRIBUTES_NAMES(SOURCE=SOURCE(TSTARTD:TENDD))
+    IF (INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>')>0) &
+      TENDD = INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>') + LEN('</'//SELF%TAG_NAME//'>') - 1
+    CALL SELF%GET(SOURCE=SOURCE(TSTARTD:TENDD))
+  ENDIF
+  IF (PRESENT(TSTART)) TSTART = TSTARTD
+  IF (PRESENT(TEND  )) TEND   = TENDD
+  ENDSUBROUTINE PARSE
+
+  PURE SUBROUTINE SET(SELF, NAME, ATTRIBUTE, ATTRIBUTES, ATTRIBUTES_STREAM, SANITIZE_ATTRIBUTES_VALUE, CONTENT, &
+                      INDENT, IS_CONTENT_INDENTED, IS_SELF_CLOSING)
+  !< SET TAG DATA.
+  CLASS(XML_TAG), INTENT(INOUT)        :: SELF                      !< XML TAG.
+  CHARACTER(*),   INTENT(IN), OPTIONAL :: NAME                      !< TAG NAME.
+  CHARACTER(*),   INTENT(IN), OPTIONAL :: ATTRIBUTE(1:)             !< ATTRIBUTE NAME/VALUE PAIR [1:2].
+  CHARACTER(*),   INTENT(IN), OPTIONAL :: ATTRIBUTES(1:,1:)         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS [1:2,1:].
+  CHARACTER(*),   INTENT(IN), OPTIONAL :: ATTRIBUTES_STREAM         !< ATTRIBUTES LIST OF NAME/VALUE PAIRS AS SINGLE STREAM.
+  LOGICAL,        INTENT(IN), OPTIONAL :: SANITIZE_ATTRIBUTES_VALUE !< SANITIZE ATTRIBUTES VALUE.
+  CHARACTER(*),   INTENT(IN), OPTIONAL :: CONTENT                   !< TAG VALUE.
+  INTEGER(I4P),   INTENT(IN), OPTIONAL :: INDENT                    !< NUMBER OF INDENT-WHITE-SPACES.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED       !< ACTIVATE VALUE INDENTATION.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_SELF_CLOSING           !< THE TAG IS SELF CLOSING.
+  LOGICAL                              :: IS_CONTENT_INDENTED_      !< ACTIVATE VALUE INDENTATION.
+
+  IF (PRESENT(NAME)) SELF%TAG_NAME = NAME
+  IF (PRESENT(ATTRIBUTE)) CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=ATTRIBUTE, SANITIZE_VALUE=SANITIZE_ATTRIBUTES_VALUE)
+  IF (PRESENT(ATTRIBUTES)) CALL SELF%ADD_MULTIPLE_ATTRIBUTES(ATTRIBUTES=ATTRIBUTES, SANITIZE_VALUES=SANITIZE_ATTRIBUTES_VALUE)
+  IF (PRESENT(ATTRIBUTES_STREAM)) CALL SELF%ADD_STREAM_ATTRIBUTES(ATTRIBUTES_STREAM=ATTRIBUTES_STREAM, &
+                                                                  SANITIZE_VALUES=SANITIZE_ATTRIBUTES_VALUE)
+  IF (PRESENT(INDENT)) SELF%INDENT = INDENT
+  IF (PRESENT(CONTENT)) THEN
+    IS_CONTENT_INDENTED_ = .FALSE. ; IF (PRESENT(IS_CONTENT_INDENTED)) IS_CONTENT_INDENTED_ = IS_CONTENT_INDENTED
+    IF (IS_CONTENT_INDENTED_) THEN
+      SELF%TAG_CONTENT = NEW_LINE('A')//REPEAT(' ', SELF%INDENT+2)//CONTENT//NEW_LINE('A')
+    ELSE
+      SELF%TAG_CONTENT = CONTENT
+    ENDIF
+  ENDIF
+  IF (PRESENT(IS_SELF_CLOSING)) SELF%IS_SELF_CLOSING = IS_SELF_CLOSING
+  ENDSUBROUTINE SET
+
+  PURE FUNCTION SELF_CLOSING_TAG(SELF, IS_INDENTED) RESULT(TAG_)
+  !< RETURN `<TAG_NAME.../>` SELF CLOSING TAG.
+  CLASS(XML_TAG), INTENT(IN)           :: SELF        !< XML TAG.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_INDENTED !< FLAG TO CHECK IF TAG IS INDENTED.
+  CHARACTER(LEN=:), ALLOCATABLE        :: TAG_        !< THE SELF CLOSING TAG STRING.
+
+  TAG_ = '<'//SELF%TAG_NAME
+  IF (SELF%ATTRIBUTES_NUMBER>0) TAG_ = TAG_//' '//SELF%ATTRIBUTES()
+  TAG_ = TAG_//'/>'
+  IF (PRESENT(IS_INDENTED)) THEN
+    IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_
+  ENDIF
+  ENDFUNCTION SELF_CLOSING_TAG
+
+  PURE FUNCTION START_TAG(SELF, IS_INDENTED) RESULT(TAG_)
+  !< RETURN `<TAG_NAME...>` START TAG.
+  CLASS(XML_TAG), INTENT(IN)           :: SELF        !< XML TAG.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_INDENTED !< FLAG TO CHECK IF TAG IS INDENTED.
+  CHARACTER(LEN=:), ALLOCATABLE        :: TAG_        !< THE START TAG STRING.
+
+  TAG_ = '<'//SELF%TAG_NAME
+  IF (SELF%ATTRIBUTES_NUMBER>0) TAG_ = TAG_//' '//SELF%ATTRIBUTES()
+  TAG_ = TAG_//'>'
+  IF (PRESENT(IS_INDENTED)) THEN
+    IF (IS_INDENTED) TAG_ = REPEAT(' ', SELF%INDENT)//TAG_
+  ENDIF
+  ENDFUNCTION START_TAG
+
+  PURE FUNCTION STRINGIFY(SELF, IS_INDENTED, IS_CONTENT_INDENTED, ONLY_START, ONLY_CONTENT, ONLY_END) RESULT(STRINGED)
+  !< CONVERT THE WHOLE TAG INTO A STRING.
+  CLASS(XML_TAG), INTENT(IN)           :: SELF                 !< XML TAG.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_INDENTED          !< ACTIVATE CONTENT INDENTATION.
+  LOGICAL,        INTENT(IN), OPTIONAL :: IS_CONTENT_INDENTED  !< ACTIVATE CONTENT INDENTATION.
+  LOGICAL,        INTENT(IN), OPTIONAL :: ONLY_START           !< WRITE ONLY START TAG.
+  LOGICAL,        INTENT(IN), OPTIONAL :: ONLY_CONTENT         !< WRITE ONLY CONTENT.
+  LOGICAL,        INTENT(IN), OPTIONAL :: ONLY_END             !< WRITE ONLY END TAG.
+  CHARACTER(LEN=:), ALLOCATABLE        :: STRINGED             !< OUTPUT STRING CONTAINING THE WHOLE TAG.
+  LOGICAL                              :: IS_CONTENT_INDENTED_ !< ACTIVATE CONTENT INDENTATION.
+  LOGICAL                              :: ONLY_START_          !< WRITE ONLY START TAG.
+  LOGICAL                              :: ONLY_CONTENT_        !< WRITE ONLY CONTENT.
+  LOGICAL                              :: ONLY_END_            !< WRITE ONLY END TAG.
+
+  IS_CONTENT_INDENTED_ = .FALSE. ; IF (PRESENT(IS_CONTENT_INDENTED)) IS_CONTENT_INDENTED_ = IS_CONTENT_INDENTED
+  ONLY_START_ = .FALSE. ; IF (PRESENT(ONLY_START)) ONLY_START_ = ONLY_START
+  ONLY_CONTENT_ = .FALSE. ; IF (PRESENT(ONLY_CONTENT)) ONLY_CONTENT_ = ONLY_CONTENT
+  ONLY_END_ = .FALSE. ; IF (PRESENT(ONLY_END)) ONLY_END_ = ONLY_END
+  IF (ONLY_START_) THEN
+    STRINGED = SELF%START_TAG(IS_INDENTED=IS_INDENTED)
+  ELSEIF (ONLY_CONTENT_) THEN
+    IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN
+      IF (IS_CONTENT_INDENTED_) THEN
+        STRINGED = REPEAT(' ', SELF%INDENT+2)//SELF%TAG_CONTENT
+      ELSE
+        STRINGED = SELF%TAG_CONTENT%CHARS()
+      ENDIF
+    ENDIF
+  ELSEIF (ONLY_END_) THEN
+    STRINGED = SELF%END_TAG(IS_INDENTED=IS_INDENTED)
+  ELSE
+    STRINGED = ''
+    IF (SELF%TAG_NAME%IS_ALLOCATED()) THEN
+      IF (SELF%IS_SELF_CLOSING) THEN
+        STRINGED = SELF%SELF_CLOSING_TAG(IS_INDENTED=IS_INDENTED)
+      ELSE
+        STRINGED = SELF%START_TAG(IS_INDENTED=IS_INDENTED)
+        IF (SELF%TAG_CONTENT%IS_ALLOCATED()) THEN
+          IF (IS_CONTENT_INDENTED_) THEN
+            STRINGED = STRINGED//NEW_LINE('A')//REPEAT(' ', SELF%INDENT+2)//&
+                       SELF%TAG_CONTENT//NEW_LINE('A')//REPEAT(' ', SELF%INDENT)
+          ELSE
+            STRINGED = STRINGED//SELF%TAG_CONTENT
+          ENDIF
+        ENDIF
+        STRINGED = STRINGED//SELF%END_TAG()
+      ENDIF
+    ENDIF
+  ENDIF
+  ENDFUNCTION STRINGIFY
+
+  SUBROUTINE WRITE_TAG(SELF, UNIT, IS_INDENTED, IS_CONTENT_INDENTED, FORM, END_RECORD, ONLY_START, ONLY_CONTENT, ONLY_END, &
+                       IOSTAT, IOMSG)
+  !< WRITE TAG TO UNIT FILE.
+  CLASS(XML_TAG), INTENT(IN)            :: SELF                !< XML TAG.
+  INTEGER(I4P),   INTENT(IN)            :: UNIT                !< FILE UNIT.
+  LOGICAL,        INTENT(IN),  OPTIONAL :: IS_INDENTED         !< ACTIVATE CONTENT INDENTATION.
+  LOGICAL,        INTENT(IN),  OPTIONAL :: IS_CONTENT_INDENTED !< ACTIVATE CONTENT INDENTATION.
+  CHARACTER(*),   INTENT(IN),  OPTIONAL :: FORM                !< FORMAT.
+  CHARACTER(*),   INTENT(IN),  OPTIONAL :: END_RECORD          !< ENDING RECORD.
+  LOGICAL,        INTENT(IN),  OPTIONAL :: ONLY_START          !< WRITE ONLY START TAG.
+  LOGICAL,        INTENT(IN),  OPTIONAL :: ONLY_CONTENT        !< WRITE ONLY CONTENT.
+  LOGICAL,        INTENT(IN),  OPTIONAL :: ONLY_END            !< WRITE ONLY END TAG.
+  INTEGER(I4P),   INTENT(OUT), OPTIONAL :: IOSTAT              !< IO STATUS.
+  CHARACTER(*),   INTENT(OUT), OPTIONAL :: IOMSG               !< IO MESSAGE.
+  TYPE(STRING)                          :: FORM_               !< FORMAT.
+  TYPE(STRING)                          :: END_RECORD_         !< ENDING RECORD.
+  INTEGER(I4P)                          :: IOSTAT_             !< IO STATUS.
+  CHARACTER(500)                        :: IOMSG_              !< IO MESSAGE.
+
+  FORM_ = 'UNFORMATTED'
+  IF (PRESENT(FORM)) THEN
+    FORM_ = FORM
+    FORM_ = FORM_%UPPER()
+  ENDIF
+  END_RECORD_ = '' ; IF (PRESENT(END_RECORD)) END_RECORD_ = END_RECORD
+  SELECT CASE(FORM_%CHARS())
+  CASE('UNFORMATTED')
+    WRITE(UNIT=UNIT, IOSTAT=IOSTAT_, IOMSG=IOMSG_)SELF%STRINGIFY(IS_INDENTED=IS_INDENTED,                 &
+                                                                 IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, &
+                                                                 ONLY_START=ONLY_START,                   &
+                                                                 ONLY_CONTENT=ONLY_CONTENT,               &
+                                                                 ONLY_END=ONLY_END)//END_RECORD_
+  CASE('FORMATTED')
+    WRITE(UNIT=UNIT, FMT='(A)', IOSTAT=IOSTAT_, IOMSG=IOMSG_)SELF%STRINGIFY(IS_INDENTED=IS_INDENTED,                 &
+                                                                            IS_CONTENT_INDENTED=IS_CONTENT_INDENTED, &
+                                                                            ONLY_START=ONLY_START,                   &
+                                                                            ONLY_CONTENT=ONLY_CONTENT,               &
+                                                                            ONLY_END=ONLY_END)//END_RECORD_
+  ENDSELECT
+  IF (PRESENT(IOSTAT)) IOSTAT = IOSTAT_
+  IF (PRESENT(IOMSG)) IOMSG = IOMSG_
+  ENDSUBROUTINE WRITE_TAG
+
+  ! PRIVATE METHODS
+  PURE FUNCTION IS_ATTRIBUTE_PRESENT(SELF, NAME) RESULT(IS_PRESENT)
+  !< RETURN .TRUE. IT THE QUERIED ATTRIBUTE NAME IS DEFINED, .FALSE. OTHERWISE.
+  CLASS(XML_TAG), INTENT(IN) :: SELF       !< XML TAG.
+  CHARACTER(*),   INTENT(IN) :: NAME       !< ATTRIBUTE NAME.
+  LOGICAL                    :: IS_PRESENT !< INQUIRE RESULT.
+  INTEGER(I4P)               :: A          !< COUNTER.
+
+  IS_PRESENT = .FALSE.
+  IF (SELF%ATTRIBUTES_NUMBER>0) THEN
+    DO A=1, SELF%ATTRIBUTES_NUMBER
+      IF (SELF%ATTRIBUTE(1, A)==NAME) THEN
+        IS_PRESENT = .TRUE.
+        EXIT
+      ENDIF
+    ENDDO
+  ENDIF
+  ENDFUNCTION IS_ATTRIBUTE_PRESENT
+
+  PURE SUBROUTINE ADD_SINGLE_ATTRIBUTE(SELF, ATTRIBUTE, SANITIZE_VALUE)
+  !< ADD ONE ATTRIBUTE NAME/VALUE PAIR.
+  !<
+  !< @NOTE LEADING AND TRAILING WHITE SPACES ARE TRIMMED OUT BY ATTRIBUTE'S NAME.
+  CLASS(XML_TAG), INTENT(INOUT)        :: SELF               !< XML TAG.
+  CHARACTER(*),   INTENT(IN)           :: ATTRIBUTE(1:)      !< ATTRIBUTE NAME/VALUE PAIR [1:2].
+  LOGICAL,        INTENT(IN), OPTIONAL :: SANITIZE_VALUE     !< SANITIZE ATTRIBUTE VALUE.
+  TYPE(STRING), ALLOCATABLE            :: NEW_ATTRIBUTE(:,:) !< TEMPORARY STORAGE FOR ATTRIBUTES.
+  LOGICAL                              :: SANITIZE_VALUE_    !< SANITIZE ATTRIBUTE VALUE.
+  LOGICAL                              :: IS_UPDATED         !< FLAG TO CHECK IF THE ATTRIBUTE HAS BEEN UPDETED.
+  INTEGER(I4P)                         :: A                  !< COUNTER.
+
+  SANITIZE_VALUE_ = .FALSE. ; IF (PRESENT(SANITIZE_VALUE)) SANITIZE_VALUE_ = SANITIZE_VALUE
+  IF (SELF%ATTRIBUTES_NUMBER>0) THEN
+    IS_UPDATED = .FALSE.
+    UPDATE_IF_ALREADY_PRESENT: DO A=1, SELF%ATTRIBUTES_NUMBER
+      IF (SELF%ATTRIBUTE(1, A)==ATTRIBUTE(1)) THEN
+        IF (SANITIZE_VALUE_) THEN
+          SELF%ATTRIBUTE(2, A) = TRIM(ADJUSTL(ATTRIBUTE(2)))
+        ELSE
+          SELF%ATTRIBUTE(2, A) = ATTRIBUTE(2)
+        ENDIF
+        IS_UPDATED = .TRUE.
+        EXIT UPDATE_IF_ALREADY_PRESENT
+      ENDIF
+    ENDDO UPDATE_IF_ALREADY_PRESENT
+    IF (.NOT.IS_UPDATED) THEN
+      ALLOCATE(NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER+1))
+      NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER) = SELF%ATTRIBUTE
+      NEW_ATTRIBUTE(1, SELF%ATTRIBUTES_NUMBER+1) = TRIM(ADJUSTL(ATTRIBUTE(1)))
+      IF (SANITIZE_VALUE_) THEN
+        NEW_ATTRIBUTE(2, SELF%ATTRIBUTES_NUMBER+1) = TRIM(ADJUSTL(ATTRIBUTE(2)))
+      ELSE
+        NEW_ATTRIBUTE(2, SELF%ATTRIBUTES_NUMBER+1) = ATTRIBUTE(2)
+      ENDIF
+      CALL MOVE_ALLOC(FROM=NEW_ATTRIBUTE, TO=SELF%ATTRIBUTE)
+      SELF%ATTRIBUTES_NUMBER = SELF%ATTRIBUTES_NUMBER + 1
+    ENDIF
+  ELSE
+    CALL SELF%ALLOC_ATTRIBUTES(NA=1)
+    SELF%ATTRIBUTE(1, 1) = TRIM(ADJUSTL(ATTRIBUTE(1)))
+    IF (SANITIZE_VALUE_) THEN
+      SELF%ATTRIBUTE(2, 1) = TRIM(ADJUSTL(ATTRIBUTE(2)))
+    ELSE
+      SELF%ATTRIBUTE(2, 1) = ATTRIBUTE(2)
+    ENDIF
+  ENDIF
+  ENDSUBROUTINE ADD_SINGLE_ATTRIBUTE
+
+  PURE SUBROUTINE ADD_MULTIPLE_ATTRIBUTES(SELF, ATTRIBUTES, SANITIZE_VALUES)
+  !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS.
+  CLASS(XML_TAG), INTENT(INOUT)        :: SELF              !< XML TAG.
+  CHARACTER(*),   INTENT(IN)           :: ATTRIBUTES(1:,1:) !< ATTRIBUTE NAME/VALUE PAIR LIST [1:2,1:].
+  LOGICAL,        INTENT(IN), OPTIONAL :: SANITIZE_VALUES   !< SANITIZE ATTRIBUTE VALUES.
+  INTEGER(I4P)                         :: A                 !< COUNTER.
+
+  DO A=1, SIZE(ATTRIBUTES, DIM=2)
+    ! NOT EFFICIENT: MANY REALLOCATION, BUT SAFE
+    CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=ATTRIBUTES(1:,A), SANITIZE_VALUE=SANITIZE_VALUES)
+  ENDDO
+  ENDSUBROUTINE ADD_MULTIPLE_ATTRIBUTES
+
+  PURE SUBROUTINE ADD_STREAM_ATTRIBUTES(SELF, ATTRIBUTES_STREAM, SANITIZE_VALUES)
+  !< ADD LIST OF ATTRIBUTES NAME/VALUE PAIRS PASSED AS STREAM.
+  !<
+  !< @NOTE THE CHARACTER `=` CANNOT COMPARE INTO THE ATTRIBUTES NAMES OF VALUES.
+  CLASS(XML_TAG), INTENT(INOUT)        :: SELF              !< XML TAG.
+  CHARACTER(*),   INTENT(IN)           :: ATTRIBUTES_STREAM !< ATTRIBUTE NAME/VALUE PAIR LIST PASSED AS STREAM.
+  LOGICAL,        INTENT(IN), OPTIONAL :: SANITIZE_VALUES   !< SANITIZE ATTRIBUTE VALUES.
+  TYPE(STRING)                         :: ATTRIBUTES_STRING !< ATTRIBUTE NAME/VALUE PAIR LIST AS STRING.
+  TYPE(STRING)                         :: TOKENS(1:3)       !< ATTRIBUTES TOKENIZED BY `=`.
+  TYPE(STRING)                         :: ATTRIBUTE(1:2)    !< ATTRIBUTE NAME/VALUE PAIR.
+  LOGICAL                              :: CONTINUE_TO_PARSE !< SENTINEL TO STOP ATTRIBUTES STREAM PARSING.
+  INTEGER(I4P)                         :: MAX_CHARS         !< COUNTER.
+
+  ATTRIBUTES_STRING = ATTRIBUTES_STREAM
+  CONTINUE_TO_PARSE = .TRUE.
+  DO WHILE(CONTINUE_TO_PARSE)
+    TOKENS = ATTRIBUTES_STRING%PARTITION(SEP='=')
+    ATTRIBUTE(1) = TRIM(ADJUSTL(TOKENS(1)))
+    IF (ATTRIBUTE(1)/='') THEN
+      TOKENS(3) = TOKENS(3)%SLICE(ISTART=TOKENS(3)%INDEX('"')+1, IEND=TOKENS(3)%LEN())
+      ATTRIBUTE(2) = TOKENS(3)%SLICE(ISTART=1, IEND=TOKENS(3)%INDEX('"')-1)
+      TOKENS(3) = TOKENS(3)%SLICE(ISTART=TOKENS(3)%INDEX('"')+1, IEND=TOKENS(3)%LEN())
+      MAX_CHARS = MAX(ATTRIBUTE(1)%LEN(), ATTRIBUTE(2)%LEN())
+      ATTRIBUTE(1) = ATTRIBUTE(1)%FILL(WIDTH=MAX_CHARS, RIGHT=.TRUE., FILLING_CHAR=' ')
+      ATTRIBUTE(2) = ATTRIBUTE(2)%FILL(WIDTH=MAX_CHARS, RIGHT=.TRUE., FILLING_CHAR=' ')
+      CALL SELF%ADD_SINGLE_ATTRIBUTE(ATTRIBUTE=[ATTRIBUTE(1)//'', ATTRIBUTE(2)//''], SANITIZE_VALUE=SANITIZE_VALUES)
+      IF (TOKENS(3)%INDEX('=')>0) THEN
+        ATTRIBUTES_STRING = TOKENS(3)
+      ELSE
+        CONTINUE_TO_PARSE = .FALSE.
+      ENDIF
+    ELSE
+      CONTINUE_TO_PARSE = .FALSE.
+    ENDIF
+  ENDDO
+  ENDSUBROUTINE ADD_STREAM_ATTRIBUTES
+
+  ELEMENTAL SUBROUTINE ALLOC_ATTRIBUTES(SELF, NA)
+  !< ALLOCATE (PREPARE FOR FILLING) DYNAMIC MEMORY OF ATTRIBUTES.
+  CLASS(XML_TAG),    INTENT(INOUT) :: SELF     !< XML TAG.
+  INTEGER(I4P),      INTENT(IN)    :: NA       !< NUMBER OF ATTRIBUTES.
+
+  IF (ALLOCATED(SELF%ATTRIBUTE)) THEN
+    CALL SELF%ATTRIBUTE%FREE
+    DEALLOCATE(SELF%ATTRIBUTE)
+  ENDIF
+  ALLOCATE(SELF%ATTRIBUTE(1:2, 1:NA))
+  SELF%ATTRIBUTES_NUMBER = NA
+  ENDSUBROUTINE ALLOC_ATTRIBUTES
+
+  PURE SUBROUTINE DELETE_CONTENT(SELF)
+  !< DELETE TAG CONTENT.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF !< XML TAG.
+
+  CALL SELF%TAG_CONTENT%FREE
+  ENDSUBROUTINE DELETE_CONTENT
+
+  PURE SUBROUTINE DELETE_SINGLE_ATTRIBUTE(SELF, NAME)
+  !< DELETE ONE ATTRIBUTE NAME/VALUE PAIR.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF               !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: NAME               !< ATTRIBUTE NAME.
+  TYPE(STRING), ALLOCATABLE     :: NEW_ATTRIBUTE(:,:) !< TEMPORARY STORAGE FOR ATTRIBUTES.
+  INTEGER(I4P)                  :: A                  !< COUNTER.
+
+  IF (SELF%ATTRIBUTES_NUMBER>0) THEN
+    SEARCH_TAG: DO A=1, SELF%ATTRIBUTES_NUMBER
+      IF (SELF%ATTRIBUTE(1, A)==NAME) THEN
+        IF (SELF%ATTRIBUTES_NUMBER>1) THEN
+          ALLOCATE(NEW_ATTRIBUTE(1:2, 1:SELF%ATTRIBUTES_NUMBER-1))
+          IF (A==1) THEN
+            NEW_ATTRIBUTE(:, A:) = SELF%ATTRIBUTE(:, A+1:)
+          ELSEIF (A==SELF%ATTRIBUTES_NUMBER) THEN
+            NEW_ATTRIBUTE(:, :A-1) = SELF%ATTRIBUTE(:, :A-1)
+          ELSE
+            NEW_ATTRIBUTE(:, :A-1) = SELF%ATTRIBUTE(:, :A-1)
+            NEW_ATTRIBUTE(:, A:) = SELF%ATTRIBUTE(:, A+1:)
+          ENDIF
+          CALL MOVE_ALLOC(FROM=NEW_ATTRIBUTE, TO=SELF%ATTRIBUTE)
+        ELSE
+          CALL SELF%ATTRIBUTE%FREE
+          DEALLOCATE(SELF%ATTRIBUTE)
+        ENDIF
+        SELF%ATTRIBUTES_NUMBER = SELF%ATTRIBUTES_NUMBER - 1
+        EXIT SEARCH_TAG
+      ENDIF
+    ENDDO SEARCH_TAG
+  ENDIF
+  ENDSUBROUTINE DELETE_SINGLE_ATTRIBUTE
+
+  PURE SUBROUTINE DELETE_MULTIPLE_ATTRIBUTES(SELF, NAME)
+  !< DELETE LIST OF ATTRIBUTES NAME/VALUE PAIRS.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF     !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: NAME(1:) !< ATTRIBUTES NAMES.
+  INTEGER(I4P)                  :: A        !< COUNTER.
+
+  DO A=1, SIZE(NAME, DIM=1)
+    CALL SELF%DELETE_SINGLE_ATTRIBUTE(NAME=NAME(A))
+  ENDDO
+  ENDSUBROUTINE DELETE_MULTIPLE_ATTRIBUTES
+
+  ELEMENTAL SUBROUTINE GET(SELF, SOURCE)
+  !< GET THE TAG CONTENT AND ATTRIBUTES FROM SOURCE AFTER TAG_NAME AND ATTRIBUTES NAMES HAVE BEEN SET.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF   !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: SOURCE !< STRING CONTAINING DATA.
+
+  CALL SELF%GET_VALUE(SOURCE=SOURCE)
+  CALL SELF%GET_ATTRIBUTES(SOURCE=SOURCE)
+  ! CALL SELF%GET_NESTED()
+  ENDSUBROUTINE GET
+
+  ELEMENTAL SUBROUTINE GET_ATTRIBUTES(SELF, SOURCE)
+  !< GET THE ATTRIBUTES VALUES FROM SOURCE AFTER TAG_NAME AND ATTRIBUTES NAMES HAVE BEEN SET.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF   !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: SOURCE !< STRING CONTAINING DATA.
+  INTEGER                       :: A      !< COUNTER.
+  INTEGER                       :: C1     !< COUNTER.
+  INTEGER                       :: C2     !< COUNTER.
+
+  IF (INDEX(STRING=SOURCE, SUBSTRING='<'//SELF%TAG_NAME)>0) THEN
+    IF (SELF%ATTRIBUTES_NUMBER>0) THEN ! PARSING ATTRIBUTES
+      DO A=1, SELF%ATTRIBUTES_NUMBER
+        C1 = INDEX(STRING=SOURCE, SUBSTRING=SELF%ATTRIBUTE(1, A)//'="') + SELF%ATTRIBUTE(1, A)%LEN() + 2
+        IF (C1>SELF%ATTRIBUTE(1, A)%LEN() + 2) THEN
+          C2 = INDEX(STRING=SOURCE(C1:), SUBSTRING='"')
+          IF (C2>0) THEN
+            SELF%ATTRIBUTE(2, A) = SOURCE(C1:C1+C2-2)
+          ELSE
+            CALL SELF%ATTRIBUTE(2, A)%FREE
+          ENDIF
+        ELSE
+          CALL SELF%ATTRIBUTE(2, A)%FREE
+        ENDIF
+      ENDDO
+    ENDIF
+  ENDIF
+  ENDSUBROUTINE GET_ATTRIBUTES
+
+  ELEMENTAL SUBROUTINE GET_VALUE(SELF, SOURCE)
+  !< GET THE TAG VALUE FROM SOURCE AFTER TAG_NAME HAS BEEN SET.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF   !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: SOURCE !< STRING CONTAINING DATA.
+  INTEGER                       :: C1     !< COUNTER.
+  INTEGER                       :: C2     !< COUNTER.
+
+  CALL SELF%TAG_CONTENT%FREE
+  SELF%IS_SELF_CLOSING = .FALSE.
+  IF (INDEX(STRING=SOURCE, SUBSTRING='<'//SELF%TAG_NAME)>0) THEN
+    C2 = INDEX(STRING=SOURCE, SUBSTRING='</'//SELF%TAG_NAME//'>')
+    IF (C2>0) THEN ! PARSING TAG VALUE
+      C1 = INDEX(STRING=SOURCE, SUBSTRING='>')
+      IF (C1+1<C2-1) SELF%TAG_CONTENT = SOURCE(C1+1:C2-1)
+    ELSE
+      SELF%IS_SELF_CLOSING = .TRUE.
+    ENDIF
+  ENDIF
+  ENDSUBROUTINE GET_VALUE
+
+  ELEMENTAL SUBROUTINE PARSE_ATTRIBUTES_NAMES(SELF, SOURCE)
+  !< PARSE THE TAG ATTRIBUTES NAMES CONTAINED INTO A STRING.
+  !<
+  !< VALID SYNTAX IS:
+  !< + `ATT1="ATT1 VAL" ATT2="ATT2 VAL"...`
+  !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED.
+  CLASS(XML_TAG), INTENT(INOUT) :: SELF   !< XML TAG.
+  CHARACTER(*),   INTENT(IN)    :: SOURCE !< STRING CONTAINING THE INPUT.
+  CHARACTER(LEN=:), ALLOCATABLE :: ATT    !< DUMMY STRING FOR PARSING FILE.
+  INTEGER(I4P)                  :: C      !< COUNTER.
+  INTEGER(I4P)                  :: S      !< COUNTER.
+  INTEGER(I4P)                  :: A      !< COUNTER.
+  INTEGER(I4P)                  :: NA     !< COUNTER.
+
+  NA = 0
+  C = 1
+  ATT_COUNT: DO WHILE(C<=LEN(SOURCE))
+    IF (SOURCE(C:C)=='=') NA = NA + 1
+    C = C + 1
+  ENDDO ATT_COUNT
+  IF (NA>0) THEN
+    CALL SELF%ALLOC_ATTRIBUTES(NA=NA)
+    C = INDEX(STRING=SOURCE, SUBSTRING=' ')
+    ATT = SOURCE(C:)
+    C = 1
+    A = 1
+    ATT_SEARCH: DO WHILE(C<=LEN(ATT))
+      IF (ATT(C:C)=='=') THEN
+        S = MAX(0, INDEX(STRING=ATT, SUBSTRING=' '))
+        SELF%ATTRIBUTE(1, A) = TRIM(ADJUSTL(ATT(S+1:C-1)))
+        ATT = ATT(C+1:)
+        C = 1
+        A = A + 1
+      ENDIF
+      C = C + 1
+    ENDDO ATT_SEARCH
+  ENDIF
+  ENDSUBROUTINE PARSE_ATTRIBUTES_NAMES
+
+  ELEMENTAL SUBROUTINE PARSE_TAG_NAME(SELF, SOURCE, TSTART, TEND)
+  !< PARSE THE TAG NAME CONTAINED INTO A STRING.
+  !<
+  !< IT IS ASSUMED THAT THE FIRST TAG CONTAINED INTO THE SOURCE IS PARSED, THE OTHERS EVENTUALLY PRESENT ARE OMITTED.
+  !< VALID SYNTAX ARE:
+  !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL"...>...</TAG_NAME>`
+  !< + `<TAG_NAME ATT1="ATT1 VAL" ATT2="ATT2 VAL".../>`
+  !< @NOTE INSIDE THE ATTRIBUTES VALUE THE SYMBOLS `<` AND `>` ARE NOT ALLOWED.
+  CLASS(XML_TAG),         INTENT(INOUT) :: SELF    !< XML TAG.
+  CHARACTER(*),           INTENT(IN)    :: SOURCE  !< STRING CONTAINING THE INPUT.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TSTART  !< STARTING INDEX OF TAG INSIDE THE SOURCE.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TEND    !< ENDING INDEX OF TAG INSIDE THE SOURCE.
+  INTEGER(I4P)                          :: TSTARTD !< STARTING INDEX OF TAG INSIDE THE SOURCE.
+  INTEGER(I4P)                          :: TENDD   !< ENDING INDEX OF TAG INSIDE THE SOURCE.
+  CHARACTER(LEN=1)                      :: C1      !< DUMMY STRING FOR PARSING FILE.
+  CHARACTER(LEN=:), ALLOCATABLE         :: C2      !< DUMMY STRING FOR PARSING FILE.
+  INTEGER(I4P)                          :: C       !< COUNTER.
+  INTEGER(I4P)                          :: S       !< COUNTER.
+
+  TSTARTD = 0
+  TENDD   = 0
+  C = 1
+  TAG_SEARCH: DO WHILE(C<=LEN(SOURCE))
+    C1 = SOURCE(C:C)
+    IF (C1=='<') THEN
+      TSTARTD = C
+      C2 = C1
+      TAG_NAME: DO WHILE(C<LEN(SOURCE))
+        C = C + 1 ; C1 = SOURCE(C:C)
+        C2 = C2//C1
+        IF (C1=='>') THEN
+          TENDD = C
+          EXIT TAG_NAME
+        ENDIF
+      ENDDO TAG_NAME
+      S = INDEX(STRING=C2, SUBSTRING=' ')
+      IF (S>0) THEN ! THERE ARE ATTRIBUTES
+        SELF%TAG_NAME = C2(2:S-1)
+      ELSE
+        IF (INDEX(STRING=C2, SUBSTRING='/>')>0) THEN ! SELF CLOSING TAG
+          SELF%TAG_NAME = C2(2:LEN(C2)-2)
+        ELSE
+          SELF%TAG_NAME = C2(2:LEN(C2)-1)
+        ENDIF
+      ENDIF
+      EXIT TAG_SEARCH
+    ENDIF
+    C = C + 1
+  ENDDO TAG_SEARCH
+  IF (PRESENT(TSTART)) TSTART = TSTARTD
+  IF (PRESENT(TEND  )) TEND   = TENDD
+  ENDSUBROUTINE PARSE_TAG_NAME
+
+  ELEMENTAL SUBROUTINE SEARCH(SELF, TAG_NAME, SOURCE, TSTART, TEND)
+  !< SEARCH TAG NAMED *TAG_NAME* INTO A STRING AND, IN CASE IT IS FOUND, STORE INTO SELF.
+  !<
+  !< @NOTE IF *TAG_NAME* IS NOT FOUND, SELF IS RETURNED EMPTY.
+  CLASS(XML_TAG),         INTENT(INOUT) :: SELF     !< XML TAG.
+  CHARACTER(*),           INTENT(IN)    :: TAG_NAME !< SEARCHED TAG NAME.
+  CHARACTER(*),           INTENT(IN)    :: SOURCE   !< STRING CONTAINING THE INPUT.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TSTART   !< STARTING INDEX OF TAG INSIDE THE SOURCE.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT)   :: TEND     !< ENDING INDEX OF TAG INSIDE THE SOURCE.
+  TYPE(XML_TAG)                         :: TAG      !< DUMMY XML TAG.
+  INTEGER(I4P)                          :: TSTART_  !< STARTING INDEX OF TAG INSIDE THE SOURCE, LOCAL VARIABLE.
+  INTEGER(I4P)                          :: TEND_    !< ENDING INDEX OF TAG INSIDE THE SOURCE, LOCAL VARIABLE.
+  LOGICAL                               :: FOUND    !< FLAG FOR INQUIRING SEARCH RESULT.
+  INTEGER(I4P)                          :: TSTART_C !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE.
+  INTEGER(I4P)                          :: TEND_C   !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE.
+  INTEGER(I4P)                          :: I
+
+  CALL SELF%FREE
+  SELF%TAG_NAME = TAG_NAME
+  TSTART_ = 1
+  TEND_   = 0
+  FOUND = .FALSE.
+  TSTART_C = 0
+  TEND_C = 0
+  TAG_SEARCH: DO
+    CALL TAG%PARSE(SOURCE=SOURCE(TEND_ + 1:), TSTART=TSTART_C, TEND=TEND_C)
+    TSTART_ = TSTART_ + TEND_
+    TEND_ = TEND_ + TEND_C
+    IF (TSTART_C==0.AND.TEND_C==0) THEN
+      EXIT TAG_SEARCH ! NO TAG FOUND
+    ELSE
+      IF (TAG%TAG_NAME%IS_ALLOCATED()) THEN
+        IF (TAG%TAG_NAME==SELF%TAG_NAME) THEN
+          FOUND = .TRUE.
+        ENDIF
+      ENDIF
+    ENDIF
+    IF (FOUND) EXIT TAG_SEARCH
+  ENDDO TAG_SEARCH
+  IF (FOUND) THEN
+    SELF = TAG
+  ELSE
+    CALL SELF%FREE
+  ENDIF
+  IF (PRESENT(TSTART)) TSTART = TSTART_
+  IF (PRESENT(TEND  )) TEND   = TEND_
+  ENDSUBROUTINE SEARCH
+
+  ! ASSIGNMENT (=)
+  ELEMENTAL SUBROUTINE ASSIGN_TAG(LHS, RHS)
+  !< ASSIGNMENT BETWEEN TWO TAGS.
+  CLASS(XML_TAG), INTENT(INOUT) :: LHS !< LEFT HAND SIDE.
+  TYPE(XML_TAG),  INTENT(IN)    :: RHS !< RIGHT HAND SIDE.
+  INTEGER(I4P)                  :: A   !< COUNTER.
+
+  CALL LHS%FREE
+  IF (RHS%TAG_NAME%IS_ALLOCATED()) LHS%TAG_NAME = RHS%TAG_NAME
+  IF (RHS%TAG_CONTENT%IS_ALLOCATED()) LHS%TAG_CONTENT = RHS%TAG_CONTENT
+  IF (RHS%ATTRIBUTES_NUMBER>0) THEN
+    ALLOCATE(LHS%ATTRIBUTE(1:2, 1:RHS%ATTRIBUTES_NUMBER))
+    DO A=1, RHS%ATTRIBUTES_NUMBER
+      LHS%ATTRIBUTE(1:2, A) = RHS%ATTRIBUTE(1:2, A)
+    ENDDO
+  ENDIF
+  LHS%ATTRIBUTES_NUMBER = RHS%ATTRIBUTES_NUMBER
+  LHS%INDENT = RHS%INDENT
+  LHS%IS_SELF_CLOSING = RHS%IS_SELF_CLOSING
+  ENDSUBROUTINE ASSIGN_TAG
+
+  ! FINALIZE
+  ELEMENTAL SUBROUTINE FINALIZE(TAG)
+  !< FREE DYNAMIC MEMORY WHEN FINALIZING.
+  TYPE(XML_TAG), INTENT(INOUT) :: TAG !< XML TAG.
+
+  CALL TAG%FREE
+  ENDSUBROUTINE FINALIZE
+ENDMODULE FOXY_XML_TAG
+
+
+
+
+
+
+!< FOXY XML FILE CLASS.
+MODULE FOXY_XML_FILE
+!< FOXY XML FILE CLASS.
+USE FOXY_XML_TAG, ONLY : XML_TAG
+USE PENF
+
+IMPLICIT NONE
+PRIVATE
+
+TYPE, PUBLIC:: XML_FILE
+  !< XML FILE CLASS.
+  !<
+  !< @TODO THE "DELETE" FACILITY IS INCOMPLETE: NESTED TAGS ARE NOT TAKEN INTO ACCOUNT. BETTER SUPPORT WILL WITH THE
+  !< "DOM" FACILITY.
+  PRIVATE
+  INTEGER(I4P)               :: NT = 0 !< NUMBER OF XML TAGS.
+  TYPE(XML_TAG), ALLOCATABLE :: TAG(:) !< XML TAGS ARRAY.
+  CONTAINS
+    ! PUBLIC METHODS
+    PROCEDURE :: FREE       !< FREE DYNAMIC MEMORY.
+    PROCEDURE :: PARSE      !< PARSE XML DATA FROM STRING OR FILE.
+    PROCEDURE :: CONTENT    !< RETURN TAG CONTENT OF TAG NAMED *NAME*.
+    PROCEDURE :: STRINGIFY  !< CONVERT THE WHOLE FILE DATA INTO A STRING.
+    PROCEDURE :: ADD_TAG    !< ADD TAG TO XML FILE.
+    PROCEDURE :: DELETE_TAG !< ADD TAG FROM XML FILE.
+    FINAL     :: FINALIZE   !< FREE DYNAMIC MEMORY WHEN FINALIZING.
+    ! PRIVATE METHODS
+    PROCEDURE, PRIVATE :: PARSE_FROM_STRING !< PARSE XML DATA FROM STRING.
+ENDTYPE XML_FILE
+CONTAINS
+  ! PUBLIC METHODS
+  ELEMENTAL SUBROUTINE FREE(SELF)
+  !< FREE DYNAMIC MEMORY.
+  CLASS(XML_FILE), INTENT(INOUT) :: SELF !< XML FILE.
+
+  IF (ALLOCATED(SELF%TAG)) THEN
+    CALL SELF%TAG%FREE
+    DEALLOCATE(SELF%TAG)
+    SELF%NT = 0
+  ENDIF
+  ENDSUBROUTINE FREE
+
+  SUBROUTINE FINALIZE(FILE)
+  !< FREE DYNAMIC MEMORY WHEN FINALIZING.
+  TYPE(XML_FILE), INTENT(INOUT) :: FILE !< XML FILE.
+
+  CALL FILE%FREE
+  ENDSUBROUTINE FINALIZE
+
+  SUBROUTINE PARSE(SELF, STRING, FILENAME)
+  !< PARSE XML DATA FROM STRING OR FILE.
+  !<
+  !< @NOTE SELF DATA ARE FREE BEFORE TRYING TO PARSE NEW XML DATA: ALL PREVIOUSLY PARSED DATA ARE LOST.
+  CLASS(XML_FILE),        INTENT(INOUT) :: SELF     !< XML FILE.
+  CHARACTER(*), OPTIONAL, INTENT(IN)    :: STRING   !< STRING CONTAINING XML DATA.
+  CHARACTER(*), OPTIONAL, INTENT(IN)    :: FILENAME !< FILE NAME CONTAINING XML DATA.
+  CHARACTER(LEN=:), ALLOCATABLE         :: SOURCE   !< STRING CONTAINING XML DATA.
+
+  CALL SELF%FREE
+  IF (PRESENT(STRING)) THEN
+    CALL SELF%PARSE_FROM_STRING(SOURCE_STRING=STRING)
+  ELSEIF (PRESENT(FILENAME)) THEN
+    SOURCE = LOAD_FILE_AS_STREAM(FILENAME=FILENAME, FAST_READ=.TRUE.)
+    CALL SELF%PARSE_FROM_STRING(SOURCE_STRING=SOURCE)
+  ENDIF
+  ENDSUBROUTINE PARSE
+
+  PURE FUNCTION CONTENT(SELF, NAME)
+  !< RETURN TAG CONTENT OF TAG NAMED *NAME*.
+  !<
+  !< @NOTE IF THERE IS NO VALUE, THE *TAG_CONTENT* STRING IS RETURNED EMPTY, BUT ALLOCATED.
+  CLASS(XML_FILE), INTENT(IN)   :: SELF    !< XML FILE.
+  CHARACTER(*),    INTENT(IN)   :: NAME    !< TAG NAME.
+  CHARACTER(LEN=:), ALLOCATABLE :: CONTENT !< TAG CONTENT.
+  INTEGER(I4P)                  :: T       !< COUNTER.
+
+  IF (ALLOCATED(CONTENT)) DEALLOCATE(CONTENT)
+  IF (SELF%NT>0) THEN
+    DO T=1, SELF%NT
+      CALL SELF%TAG(T)%GET_CONTENT(NAME=NAME, CONTENT=CONTENT)
+      IF (ALLOCATED(CONTENT)) EXIT
+    ENDDO
+  ENDIF
+  IF (.NOT.ALLOCATED(CONTENT)) CONTENT = ''
+  ENDFUNCTION CONTENT
+
+  PURE FUNCTION STRINGIFY(SELF) RESULT(STRING)
+  !< CONVERT THE WHOLE FILE DATA INTO A STRING.
+  CLASS(XML_FILE), INTENT(IN)   :: SELF       !< XML FILE.
+  CHARACTER(LEN=:), ALLOCATABLE :: STRING     !< OUTPUT STRING CONTAINING THE WHOLE XML FILE.
+  CHARACTER(LEN=:), ALLOCATABLE :: TAG_STRING !< OUTPUT STRING CONTAINING THE CURRENT TAG.
+  INTEGER(I4P)                  :: T          !< COUNTER.
+
+  STRING = ''
+  IF (SELF%NT>0) THEN
+    DO T=1, SELF%NT - 1
+      TAG_STRING = SELF%TAG(T)%STRINGIFY()
+      STRING = STRING//TAG_STRING//NEW_LINE('A')
+    ENDDO
+    TAG_STRING = SELF%TAG(SELF%NT)%STRINGIFY()
+    STRING = STRING//TAG_STRING
+  ENDIF
+  ENDFUNCTION STRINGIFY
+
+  ELEMENTAL SUBROUTINE ADD_TAG(SELF, TAG)
+  !< ADD TAG TO XML FILE.
+  CLASS(XML_FILE), INTENT(INOUT) :: SELF       !< XML FILE.
+  TYPE(XML_TAG),   INTENT(IN)    :: TAG        !< XML TAG.
+  TYPE(XML_TAG), ALLOCATABLE     :: TAG_NEW(:) !< NEW (EXTENDED) TAGS ARRAY.
+
+  IF (SELF%NT>0_I4P) THEN
+    ALLOCATE(TAG_NEW(1:SELF%NT + 1))
+    TAG_NEW(1:SELF%NT) = SELF%TAG(1:SELF%NT)
+    TAG_NEW(SELF%NT + 1) = TAG
+  ELSE
+    ALLOCATE(TAG_NEW(1:1))
+    TAG_NEW(1) = TAG
+  ENDIF
+  CALL MOVE_ALLOC(FROM=TAG_NEW, TO=SELF%TAG)
+  SELF%NT = SELF%NT + 1
+  ENDSUBROUTINE ADD_TAG
+
+  ELEMENTAL SUBROUTINE DELETE_TAG(SELF, NAME)
+  !< DELETE TAG FROM XML FILE.
+  CLASS(XML_FILE), INTENT(INOUT) :: SELF       !< XML FILE.
+  CHARACTER(*),    INTENT(IN)    :: NAME       !< XML TAG NAME.
+  TYPE(XML_TAG), ALLOCATABLE     :: TAG_NEW(:) !< NEW (EXTENDED) TAGS ARRAY.
+  INTEGER(I4P)                   :: T          !< COUNTER.
+
+  IF (SELF%NT>0_I4P) THEN
+    DO T=1, SELF%NT
+      IF (NAME==SELF%TAG(T)%NAME()) THEN
+        ALLOCATE(TAG_NEW(1:SELF%NT - 1))
+        IF (T==1) THEN
+          TAG_NEW(T:) = SELF%TAG(T+1:)
+        ELSEIF (T==SELF%NT) THEN
+          TAG_NEW(:T-1) = SELF%TAG(:T-1)
+        ELSE
+          TAG_NEW(:T-1) = SELF%TAG(:T-1)
+          TAG_NEW(T:) = SELF%TAG(T+1:)
+        ENDIF
+        CALL MOVE_ALLOC(FROM=TAG_NEW, TO=SELF%TAG)
+        SELF%NT = SELF%NT - 1
+        EXIT
+      ENDIF
+    ENDDO
+  ENDIF
+  ENDSUBROUTINE DELETE_TAG
+
+  ! PRIVATE METHODS
+  SUBROUTINE PARSE_FROM_STRING(SELF, SOURCE_STRING)
+  !< PARSE XML DATA FROM STRING.
+  CLASS(XML_FILE), INTENT(INOUT) :: SELF          !< XML FILE.
+  CHARACTER(*),    INTENT(IN)    :: SOURCE_STRING !< STRING CONTAINING XML DATA.
+  TYPE(XML_TAG)                  :: TAG           !< DUMMY XML TAG.
+  INTEGER(I4P)                   :: TSTART        !< COUNTER FOR TRACKING STRING PARSING.
+  INTEGER(I4P)                   :: TEND          !< COUNTER FOR TRACKING STRING PARSING.
+
+  TSTART = 1
+  TEND = 0
+  DO WHILE(TSTART<LEN(SOURCE_STRING))
+    CALL TAG%FREE
+    CALL TAG%PARSE(SOURCE=SOURCE_STRING(TSTART:), TEND=TEND)
+    IF (TEND==0) EXIT
+    IF (TAG%IS_PARSED()) CALL SELF%ADD_TAG(TAG)
+    TSTART = TSTART + TEND
+  ENDDO
+  ENDSUBROUTINE PARSE_FROM_STRING
+
+  ! NON TBP
+  FUNCTION LOAD_FILE_AS_STREAM(FILENAME, DELIMITER_START, DELIMITER_END, FAST_READ, IOSTAT, IOMSG) RESULT(STREAM)
+  !< LOAD FILE CONTENTS AND STORE AS SINGLE CHARACTERS STREAM.
+  CHARACTER(*),           INTENT(IN)  :: FILENAME        !< FILE NAME.
+  CHARACTER(*), OPTIONAL, INTENT(IN)  :: DELIMITER_START !< DELIMITER FROM WHICH START THE STREAM.
+  CHARACTER(*), OPTIONAL, INTENT(IN)  :: DELIMITER_END   !< DELIMITER TO WHICH END THE STREAM.
+  LOGICAL,      OPTIONAL, INTENT(IN)  :: FAST_READ       !< FLAG FOR ACTIVATING EFFICIENT READING WITH ONE SINGLE READ.
+  INTEGER(I4P), OPTIONAL, INTENT(OUT) :: IOSTAT          !< IO ERROR.
+  CHARACTER(*), OPTIONAL, INTENT(OUT) :: IOMSG           !< IO ERROR MESSAGE.
+  CHARACTER(LEN=:), ALLOCATABLE       :: STREAM          !< OUTPUT STRING CONTAINING THE FILE DATA AS A SINGLE STREAM.
+  LOGICAL                             :: IS_FILE         !< FLAG FOR INQUIRING THE PRESENCE OF THE FILE.
+  INTEGER(I4P)                        :: UNIT            !< UNIT FILE.
+  INTEGER(I4P)                        :: IOSTATD         !< IO ERROR.
+  CHARACTER(500)                      :: IOMSGD          !< IO ERROR MESSAGE.
+  CHARACTER(1)                        :: C1              !< SINGLE CHARACTER.
+  CHARACTER(LEN=:), ALLOCATABLE       :: STRING          !< DUMMY STRING.
+  LOGICAL                             :: CSTART          !< FLAG FOR STREAM CAPTURING TRIGGING.
+  LOGICAL                             :: CEND            !< FLAG FOR STREAM CAPTURING TRIGGING.
+  LOGICAL                             :: FAST            !< FLAG FOR ACTIVATING EFFICIENT READING WITH ONE SINGLE READ.
+  INTEGER(I4P)                        :: FILESIZE        !< SIZE OF THE FILE FOR FAST READING.
+
+  FAST = .FALSE. ; IF (PRESENT(FAST_READ)) FAST = FAST_READ
+  ! INQUIRE FILE EXISTANCE
+  INQUIRE(FILE=ADJUSTL(TRIM(FILENAME)), EXIST=IS_FILE, IOSTAT=IOSTATD, IOMSG=IOMSGD)
+  IF (.NOT.IS_FILE) THEN
+    IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD
+    IF (PRESENT(IOMSG )) IOMSG  = IOMSGD
+    RETURN
+  ENDIF
+  ! OPEN FILE
+  OPEN(NEWUNIT=UNIT, FILE=ADJUSTL(TRIM(FILENAME)), ACCESS='STREAM', FORM='UNFORMATTED', IOSTAT=IOSTATD, IOMSG=IOMSGD)
+  IF (IOSTATD/=0) THEN
+    IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD
+    IF (PRESENT(IOMSG )) IOMSG  = IOMSGD
+    RETURN
+  ENDIF
+  ! LOADG DATA
+  STREAM = ''
+  IF (PRESENT(DELIMITER_START).AND.PRESENT(DELIMITER_END)) THEN
+    ! LOAD ONLY DATA INSIDE DELIMITER_START AND DELIMITER_END
+    STRING = ''
+    MAIN_READ_LOOP: DO
+      READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1
+      IF (C1==DELIMITER_START(1:1)) THEN
+        CSTART = .TRUE.
+        STRING = C1
+        START_READ_LOOP: DO WHILE(LEN(STRING)<LEN(DELIMITER_START))
+          READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1
+          STRING = STRING//C1
+          IF (.NOT.(INDEX(STRING=DELIMITER_START, SUBSTRING=STRING)>0)) THEN
+            CSTART = .FALSE.
+            EXIT START_READ_LOOP
+          ENDIF
+        ENDDO START_READ_LOOP
+        IF (CSTART) THEN
+          CEND = .FALSE.
+          STREAM = STRING
+          DO WHILE(.NOT.CEND)
+            READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1
+            IF (C1==DELIMITER_END(1:1)) THEN ! MAYBE THE END
+              STRING = C1
+              END_READ_LOOP: DO WHILE(LEN(STRING)<LEN(DELIMITER_END))
+                READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)C1
+                STRING = STRING//C1
+                IF (.NOT.(INDEX(STRING=DELIMITER_END, SUBSTRING=STRING)>0)) THEN
+                  STREAM = STREAM//STRING
+                  EXIT END_READ_LOOP
+                ELSEIF (LEN(STRING)==LEN(DELIMITER_END)) THEN
+                  CEND = .TRUE.
+                  STREAM = STREAM//STRING
+                  EXIT MAIN_READ_LOOP
+                ENDIF
+              ENDDO END_READ_LOOP
+            ELSE
+              STREAM = STREAM//C1
+            ENDIF
+          ENDDO
+        ENDIF
+      ENDIF
+    ENDDO MAIN_READ_LOOP
+  ELSE
+    ! LOAD ALL DATA
+    IF (FAST) THEN
+      ! LOAD FAST
+      INQUIRE(FILE=ADJUSTL(TRIM(FILENAME)), SIZE=FILESIZE, IOSTAT=IOSTATD, IOMSG=IOMSGD)
+      IF (IOSTATD==0) THEN
+        IF (ALLOCATED(STREAM)) DEALLOCATE(STREAM)
+        ALLOCATE(CHARACTER(LEN=FILESIZE):: STREAM)
+        READ(UNIT=UNIT, IOSTAT=IOSTATD, IOMSG=IOMSGD, END=10)STREAM
+      ENDIF
+    ELSE
+      ! LOAD SLOW, ONE CHARACTER LOOP
+      READ_LOOP: DO
+        READ(UNIT=UNIT,IOSTAT=IOSTATD,IOMSG=IOMSGD,END=10)C1
+        STREAM = STREAM//C1
+      ENDDO READ_LOOP
+    ENDIF
+  ENDIF
+  10 CLOSE(UNIT)
+  IF (PRESENT(IOSTAT)) IOSTAT = IOSTATD
+  IF (PRESENT(IOMSG))  IOMSG  = IOMSGD
+  ENDFUNCTION LOAD_FILE_AS_STREAM
+ENDMODULE FOXY_XML_FILE
+
+
+
+
+
+
+
+!< FOXY, FORTRAN XML PARSER FOR POOR PEOPLE
+MODULE FOXY
+!< FOXY, FORTRAN XML PARSER FOR POOR PEOPLE
+USE FOXY_XML_FILE, ONLY : XML_FILE
+USE FOXY_XML_TAG, ONLY : XML_TAG
+USE PENF
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: I1P, I2P, I4P, I8P, R4P, R8P
+PUBLIC :: XML_FILE
+PUBLIC :: XML_TAG
+ENDMODULE FOXY
+
+
+
+
+
+
+!< VTK_FORTRAN PARAMETERS.
+MODULE VTK_FORTRAN_PARAMETERS
+!< VTK_FORTRAN PARAMETERS.
+USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : OUTPUT_UNIT, ERROR_UNIT
+USE PENF
+
+IMPLICIT NONE
+PRIVATE
+SAVE
+PUBLIC :: STDERR
+PUBLIC :: STDOUT
+PUBLIC :: END_REC
+
+INTEGER(I4P), PARAMETER :: STDERR = ERROR_UNIT  !< STANDARD ERROR UNIT.
+INTEGER(I4P), PARAMETER :: STDOUT = OUTPUT_UNIT !< STANDARD OUTPUT UNIT.
+CHARACTER(1), PARAMETER :: END_REC = CHAR(10)   !< END-CHARACTER FOR BINARY-RECORD FINALIZE.
+ENDMODULE VTK_FORTRAN_PARAMETERS
+
+
+!< VTK FILE ABSTRACT XML WRITER.
+MODULE VTKF_FILE_XML_WRITER_ABSTRACT
+!< VTK FILE ABSTRACT XML WRITER.
+USE FOXY
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_PARAMETERS
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_ABSTRACT
+
+TYPE, ABSTRACT :: XML_WRITER_ABSTRACT
+  !< VTK FILE ABSTRACT XML WRITER.
+  TYPE(STRING)  :: FORMAT_CH                       !< OUTPUT FORMAT, STRING CODE.
+  TYPE(STRING)  :: TOPOLOGY                        !< MESH TOPOLOGY.
+  INTEGER(I4P)  :: INDENT=0_I4P                    !< INDENT COUNT.
+  INTEGER(I8P)  :: IOFFSET=0_I8P                   !< OFFSET COUNT.
+  INTEGER(I4P)  :: XML=0_I4P                       !< XML LOGICAL UNIT.
+  INTEGER(I4P)  :: VTM_BLOCK(1:2)=[-1_I4P, -1_I4P] !< BLOCK INDEXES.
+  INTEGER(I4P)  :: ERROR=0_I4P                     !< IO ERROR STATUS.
+  TYPE(XML_TAG) :: TAG                             !< XML TAGS HANDLER.
+  LOGICAL       :: IS_VOLATILE=.FALSE.             !< FLAG TO CHECK VOLATILE WRITER.
+  TYPE(STRING)  :: XML_VOLATILE                    !< XML FILE VOLATILE (NOT A PHYSICAL FILE).
+  CONTAINS
+    ! PUBLIC METHODS (SOME DEFERRED)
+    PROCEDURE,                                 PASS(SELF) :: CLOSE_XML_FILE               !< CLOSE XML FILE.
+    PROCEDURE,                                 PASS(SELF) :: OPEN_XML_FILE                !< OPEN XML FILE.
+    PROCEDURE,                                 PASS(SELF) :: FREE                         !< FREE ALLOCATED MEMORY.
+    PROCEDURE,                                 PASS(SELF) :: GET_XML_VOLATILE             !< RETURN THE XML VOLATILE STRING FILE.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_CONNECTIVITY           !< WRITE CONNECTIVITY.
+    PROCEDURE,                                 PASS(SELF) :: W_DATA_LOCATION_TAG !< WRITE DATAARRAY LOCATION TAG.
+    PROCEDURE,                                 PASS(SELF) :: W_DATA_TAG          !< WRITE DATAARRAY TAG.
+    PROCEDURE,                                 PASS(SELF) :: W_DATA_TAG_APPENDED !< WRITE DATAARRAY APPENDED TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_END_TAG                !< WRITE `</TAG_NAME>` END TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_HEADER_TAG             !< WRITE HEADER TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_PARALLEL_OPEN_BLOCK    !< WRITE PARALLEL OPEN BLOCK.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_PARALLEL_CLOSE_BLOCK   !< WRITE PARALLEL CLOSE BLOCK.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_PARALLEL_DATAARRAY     !< WRITE PARALLEL DATAARRAY.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_PARALLEL_GEO           !< WRITE PARALLEL GEO.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_SELF_CLOSING_TAG       !< WRITE SELF CLOSING TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_START_TAG              !< WRITE START TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_TAG                    !< WRITE TAG.
+    PROCEDURE,                                 PASS(SELF) :: WRITE_TOPOLOGY_TAG           !< WRITE TOPOLOGY TAG.
+    PROCEDURE(INITIALIZE_INTERFACE), DEFERRED, PASS(SELF) :: INITIALIZE                   !< INITIALIZE WRITER.
+    PROCEDURE(FINALIZE_INTERFACE),   DEFERRED, PASS(SELF) :: FINALIZE                     !< FINALIZE WRITER.
+    GENERIC :: W_DATA =>          &
+               W_DATA1_RANK1_R8P, &
+               W_DATA1_RANK1_R4P, &
+               W_DATA1_RANK1_I8P, &
+               W_DATA1_RANK1_I4P, &
+               W_DATA1_RANK1_I2P, &
+               W_DATA1_RANK1_I1P, &
+               W_DATA1_RANK2_R8P, &
+               W_DATA1_RANK2_R4P, &
+               W_DATA1_RANK2_I8P, &
+               W_DATA1_RANK2_I4P, &
+               W_DATA1_RANK2_I2P, &
+               W_DATA1_RANK2_I1P, &
+               W_DATA1_RANK3_R8P, &
+               W_DATA1_RANK3_R4P, &
+               W_DATA1_RANK3_I8P, &
+               W_DATA1_RANK3_I4P, &
+               W_DATA1_RANK3_I2P, &
+               W_DATA1_RANK3_I1P, &
+               W_DATA1_RANK4_R8P, &
+               W_DATA1_RANK4_R4P, &
+               W_DATA1_RANK4_I8P, &
+               W_DATA1_RANK4_I4P, &
+               W_DATA1_RANK4_I2P, &
+               W_DATA1_RANK4_I1P, &
+               W_DATA3_RANK1_R8P, &
+               W_DATA3_RANK1_R4P, &
+               W_DATA3_RANK1_I8P, &
+               W_DATA3_RANK1_I4P, &
+               W_DATA3_RANK1_I2P, &
+               W_DATA3_RANK1_I1P, &
+               W_DATA3_RANK3_R8P, &
+               W_DATA3_RANK3_R4P, &
+               W_DATA3_RANK3_I8P, &
+               W_DATA3_RANK3_I4P, &
+               W_DATA3_RANK3_I2P, &
+               W_DATA3_RANK3_I1P, &
+               W_DATA6_RANK1_R8P, &
+               W_DATA6_RANK1_R4P, &
+               W_DATA6_RANK1_I8P, &
+               W_DATA6_RANK1_I4P, &
+               W_DATA6_RANK1_I2P, &
+               W_DATA6_RANK1_I1P, &
+               W_DATA6_RANK3_R8P, &
+               W_DATA6_RANK3_R4P, &
+               W_DATA6_RANK3_I8P, &
+               W_DATA6_RANK3_I4P, &
+               W_DATA6_RANK3_I2P, &
+               W_DATA6_RANK3_I1P, &
+               W_DATA_LOCATION_TAG !< WRITE DATA (ARRAY).
+    GENERIC :: WRITE_FIELDDATA =>      &
+               WRITE_FIELDDATA1_RANK0, &
+               WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG.
+    GENERIC :: WRITE_GEO =>                    &
+               WRITE_GEO_STRG_DATA1_RANK2_R8P, &
+               WRITE_GEO_STRG_DATA1_RANK2_R4P, &
+               WRITE_GEO_STRG_DATA1_RANK4_R8P, &
+               WRITE_GEO_STRG_DATA1_RANK4_R4P, &
+               WRITE_GEO_STRG_DATA3_RANK1_R8P, &
+               WRITE_GEO_STRG_DATA3_RANK1_R4P, &
+               WRITE_GEO_STRG_DATA3_RANK3_R8P, &
+               WRITE_GEO_STRG_DATA3_RANK3_R4P, &
+               WRITE_GEO_RECT_DATA3_RANK1_R8P, &
+               WRITE_GEO_RECT_DATA3_RANK1_R4P, &
+               WRITE_GEO_UNST_DATA1_RANK2_R8P, &
+               WRITE_GEO_UNST_DATA1_RANK2_R4P, &
+               WRITE_GEO_UNST_DATA3_RANK1_R8P, &
+               WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE MESH.
+    GENERIC :: WRITE_PARALLEL_BLOCK_FILES =>     &
+               WRITE_PARALLEL_BLOCK_FILE,        &
+               WRITE_PARALLEL_BLOCK_FILES_ARRAY, &
+               WRITE_PARALLEL_BLOCK_FILES_STRING !< WRITE BLOCK LIST OF FILES.
+    GENERIC :: WRITE_PIECE =>              &
+               WRITE_PIECE_START_TAG,      &
+               WRITE_PIECE_START_TAG_UNST, &
+               WRITE_PIECE_END_TAG !< WRITE PIECE START/END TAG.
+    ! DEFERRED METHODS
+    PROCEDURE(W_DATA1_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_R8P !< DATA 1, RANK 1, R8P.
+    PROCEDURE(W_DATA1_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_R4P !< DATA 1, RANK 1, R4P.
+    PROCEDURE(W_DATA1_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I8P !< DATA 1, RANK 1, I8P.
+    PROCEDURE(W_DATA1_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I4P !< DATA 1, RANK 1, I4P.
+    PROCEDURE(W_DATA1_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I2P !< DATA 1, RANK 1, I2P.
+    PROCEDURE(W_DATA1_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I1P !< DATA 1, RANK 1, I1P.
+    PROCEDURE(W_DATA1_RANK2_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R8P !< DATA 1, RANK 2, R8P.
+    PROCEDURE(W_DATA1_RANK2_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R4P !< DATA 1, RANK 2, R4P.
+    PROCEDURE(W_DATA1_RANK2_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I8P !< DATA 1, RANK 2, I8P.
+    PROCEDURE(W_DATA1_RANK2_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I4P !< DATA 1, RANK 2, I4P.
+    PROCEDURE(W_DATA1_RANK2_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I2P !< DATA 1, RANK 2, I2P.
+    PROCEDURE(W_DATA1_RANK2_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I1P !< DATA 1, RANK 2, I1P.
+    PROCEDURE(W_DATA1_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R8P !< DATA 1, RANK 3, R8P.
+    PROCEDURE(W_DATA1_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R4P !< DATA 1, RANK 3, R4P.
+    PROCEDURE(W_DATA1_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I8P !< DATA 1, RANK 3, I8P.
+    PROCEDURE(W_DATA1_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I4P !< DATA 1, RANK 3, I4P.
+    PROCEDURE(W_DATA1_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I2P !< DATA 1, RANK 3, I2P.
+    PROCEDURE(W_DATA1_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I1P !< DATA 1, RANK 3, I1P.
+    PROCEDURE(W_DATA1_RANK4_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R8P !< DATA 1, RANK 4, R8P.
+    PROCEDURE(W_DATA1_RANK4_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R4P !< DATA 1, RANK 4, R4P.
+    PROCEDURE(W_DATA1_RANK4_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I8P !< DATA 1, RANK 4, I8P.
+    PROCEDURE(W_DATA1_RANK4_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I4P !< DATA 1, RANK 4, I4P.
+    PROCEDURE(W_DATA1_RANK4_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I2P !< DATA 1, RANK 4, I2P.
+    PROCEDURE(W_DATA1_RANK4_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I1P !< DATA 1, RANK 4, I1P.
+    PROCEDURE(W_DATA3_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R8P !< DATA 3, RANK 1, R8P.
+    PROCEDURE(W_DATA3_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R4P !< DATA 3, RANK 1, R4P.
+    PROCEDURE(W_DATA3_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I8P !< DATA 3, RANK 1, I8P.
+    PROCEDURE(W_DATA3_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I4P !< DATA 3, RANK 1, I4P.
+    PROCEDURE(W_DATA3_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I2P !< DATA 3, RANK 1, I2P.
+    PROCEDURE(W_DATA3_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I1P !< DATA 3, RANK 1, I1P.
+    PROCEDURE(W_DATA3_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R8P !< DATA 3, RANK 3, R8P.
+    PROCEDURE(W_DATA3_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R4P !< DATA 3, RANK 3, R4P.
+    PROCEDURE(W_DATA3_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I8P !< DATA 3, RANK 3, I8P.
+    PROCEDURE(W_DATA3_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I4P !< DATA 3, RANK 3, I4P.
+    PROCEDURE(W_DATA3_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I2P !< DATA 3, RANK 3, I2P.
+    PROCEDURE(W_DATA3_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I1P !< DATA 3, RANK 3, I1P.
+    PROCEDURE(W_DATA6_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R8P !< DATA 3, RANK 1, R8P.
+    PROCEDURE(W_DATA6_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R4P !< DATA 3, RANK 1, R4P.
+    PROCEDURE(W_DATA6_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I8P !< DATA 3, RANK 1, I8P.
+    PROCEDURE(W_DATA6_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I4P !< DATA 3, RANK 1, I4P.
+    PROCEDURE(W_DATA6_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I2P !< DATA 3, RANK 1, I2P.
+    PROCEDURE(W_DATA6_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I1P !< DATA 3, RANK 1, I1P.
+    PROCEDURE(W_DATA6_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R8P !< DATA 3, RANK 3, R8P.
+    PROCEDURE(W_DATA6_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R4P !< DATA 3, RANK 3, R4P.
+    PROCEDURE(W_DATA6_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I8P !< DATA 3, RANK 3, I8P.
+    PROCEDURE(W_DATA6_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I4P !< DATA 3, RANK 3, I4P.
+    PROCEDURE(W_DATA6_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I2P !< DATA 3, RANK 3, I2P.
+    PROCEDURE(W_DATA6_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I1P !< DATA 3, RANK 3, I1P.
+    PROCEDURE(W_DATA_APPENDED_INTERFACE),   DEFERRED, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
+    ! PRIVATE METHODS
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA1_RANK0            !< WRITE FIELDDATA TAG (DATA 1, RANK 0, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA_TAG               !< WRITE FIELDDATA TAG.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R8P    !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R4P    !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R8P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG             !< WRITE `<PIECE ...>` START TAG.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG_UNST        !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_END_TAG               !< WRITE `</PIECE>` END TAG.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILE         !< WRITE SINGLE FILE THAT BELONG TO THE CURRENT BLOCK.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILES_ARRAY  !< WRITE BLOCK LIST OF FILES (ARRAY INPUT).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PARALLEL_BLOCK_FILES_STRING !< WRITE BLOCK LIST OF FILES (STRING INPUT).
+ENDTYPE XML_WRITER_ABSTRACT
+
+ABSTRACT INTERFACE
+  FUNCTION INITIALIZE_INTERFACE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
+                                IS_VOLATILE, MESH_KIND) RESULT(ERROR)
+  !< INITIALIZE WRITER.
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: FORMAT        !< FILE FORMAT: ASCII.
+  CHARACTER(*),               INTENT(IN)           :: FILENAME      !< FILE NAME.
+  CHARACTER(*),               INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+  CHARACTER(*),               INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION INITIALIZE_INTERFACE
+
+   FUNCTION FINALIZE_INTERFACE(SELF) RESULT(ERROR)
+   !< FINALIZE WRITER.
+   IMPORT :: XML_WRITER_ABSTRACT, I4P
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+   ENDFUNCTION FINALIZE_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_R8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_R4P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_R4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_I8P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_I8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_I4P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_I4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_I2P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_I2P_INTERFACE
+
+  FUNCTION W_DATA1_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK1_I1P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_R8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_R4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_I8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_I4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_I2P_INTERFACE
+
+  FUNCTION W_DATA1_RANK2_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK2_I1P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_R8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_R4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_I8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_I4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_I2P_INTERFACE
+
+  FUNCTION W_DATA1_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK3_I1P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_R8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_R4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_I8P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_I4P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_I2P_INTERFACE
+
+  FUNCTION W_DATA1_RANK4_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  ENDFUNCTION W_DATA1_RANK4_I1P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_R8P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_R4P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_I8P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_I4P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_I2P_INTERFACE
+
+  FUNCTION W_DATA3_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK1_I1P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_R8P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_R4P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_I8P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_I4P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_I2P_INTERFACE
+
+  FUNCTION W_DATA3_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA3_RANK3_I1P_INTERFACE
+  
+  FUNCTION W_DATA6_RANK1_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_R8P_INTERFACE
+
+  FUNCTION W_DATA6_RANK1_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_R4P_INTERFACE
+
+  FUNCTION W_DATA6_RANK1_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_I8P_INTERFACE
+
+  FUNCTION W_DATA6_RANK1_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_I4P_INTERFACE
+
+  FUNCTION W_DATA6_RANK1_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_I2P_INTERFACE
+
+  FUNCTION W_DATA6_RANK1_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK1_I1P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_R8P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_R4P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_I8P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  IMPORT :: XML_WRITER_ABSTRACT, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_I4P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_I2P_INTERFACE
+
+  FUNCTION W_DATA6_RANK3_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  ENDFUNCTION W_DATA6_RANK3_I1P_INTERFACE
+
+  SUBROUTINE W_DATA_APPENDED_INTERFACE(SELF)
+  !< WRITE `<APPENDEDDATA...>...</APPENDEDDATA>` TAG.
+  IMPORT :: XML_WRITER_ABSTRACT
+  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER.
+  ENDSUBROUTINE W_DATA_APPENDED_INTERFACE
+ENDINTERFACE
+CONTAINS
+   ! FILES METHODS
+   SUBROUTINE CLOSE_XML_FILE(SELF)
+   !< CLOSE XML FILE.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER.
+
+   IF (.NOT.SELF%IS_VOLATILE) CLOSE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)
+   ENDSUBROUTINE CLOSE_XML_FILE
+
+   SUBROUTINE OPEN_XML_FILE(SELF, FILENAME)
+   !< OPEN XML FILE.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF     !< WRITER.
+   CHARACTER(*),               INTENT(IN)    :: FILENAME !< FILE NAME.
+
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      OPEN(NEWUNIT=SELF%XML,             &
+           FILE=TRIM(ADJUSTL(FILENAME)), &
+           FORM='UNFORMATTED',           &
+           ACCESS='STREAM',              &
+           ACTION='WRITE',               &
+           STATUS='REPLACE',             &
+           IOSTAT=SELF%ERROR)
+   ELSE
+      SELF%XML_VOLATILE = ''
+   ENDIF
+   ENDSUBROUTINE OPEN_XML_FILE
+
+   ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
+   !< FREE ALLOCATED MEMORY.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)         :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS.
+
+   CALL SELF%FORMAT_CH%FREE
+   CALL SELF%TOPOLOGY%FREE
+   SELF%INDENT=0_I4P
+   SELF%IOFFSET=0_I8P
+   SELF%XML=0_I4P
+   SELF%VTM_BLOCK(1:2)=[-1_I4P, -1_I4P]
+   SELF%ERROR=0_I4P
+   CALL SELF%TAG%FREE
+   SELF%IS_VOLATILE=.FALSE.
+   CALL SELF%XML_VOLATILE%FREE
+   ENDSUBROUTINE FREE
+
+   PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR)
+   !< RETURN THE EVENTUAL XML VOLATILE STRING FILE.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(IN)               :: SELF         !< WRITER.
+   CHARACTER(LEN=:),           INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE.
+   INTEGER(I4P),               INTENT(OUT), OPTIONAL    :: ERROR        !< ERROR STATUS.
+
+   IF (SELF%IS_VOLATILE) THEN
+      XML_VOLATILE = SELF%XML_VOLATILE%RAW
+   ENDIF
+   ENDSUBROUTINE GET_XML_VOLATILE
+
+   ! TAG METHODS
+   SUBROUTINE WRITE_END_TAG(SELF, NAME)
+   !< WRITE `</TAG_NAME>` END TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF !< WRITER.
+   CHARACTER(*),               INTENT(IN)    :: NAME !< TAG NAME.
+
+   SELF%INDENT = SELF%INDENT - 2
+   SELF%TAG = XML_TAG(NAME=NAME, INDENT=SELF%INDENT)
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC, ONLY_END=.TRUE.)
+   ELSE
+      SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., ONLY_END=.TRUE.)//END_REC
+   ENDIF
+   ENDSUBROUTINE WRITE_END_TAG
+
+   SUBROUTINE WRITE_HEADER_TAG(SELF)
+   !< WRITE HEADER TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF   !< WRITER.
+   TYPE(STRING)                              :: BUFFER !< BUFFER STRING.
+
+   BUFFER = '<?xml version="1.0"?>'//END_REC
+   IF (ENDIAN==ENDIANL) THEN
+      BUFFER = BUFFER//'<VTKFile type="'//SELF%TOPOLOGY//'" version="1.0" byte_order="LittleEndian">'
+   ELSE
+      BUFFER = BUFFER//'<VTKFile type="'//SELF%TOPOLOGY//'" version="1.0" byte_order="BigEndian">'
+   ENDIF
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)BUFFER//END_REC
+   ELSE
+      SELF%XML_VOLATILE = SELF%XML_VOLATILE//BUFFER//END_REC
+   ENDIF
+   SELF%INDENT = 2
+   ENDSUBROUTINE WRITE_HEADER_TAG
+
+   SUBROUTINE WRITE_SELF_CLOSING_TAG(SELF, NAME, ATTRIBUTES)
+   !< WRITE `<TAG_NAME.../>` SELF CLOSING TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF       !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: NAME       !< TAG NAME.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES.
+
+   SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., INDENT=SELF%INDENT, &
+                      IS_SELF_CLOSING=.TRUE.)
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC)
+   ELSE
+      SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE.)//END_REC
+   ENDIF
+   ENDSUBROUTINE WRITE_SELF_CLOSING_TAG
+
+   SUBROUTINE WRITE_START_TAG(SELF, NAME, ATTRIBUTES)
+   !< WRITE `<TAG_NAME...>` START TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF       !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: NAME       !< TAG NAME.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES.
+
+   SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., INDENT=SELF%INDENT)
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., END_RECORD=END_REC, ONLY_START=.TRUE.)
+   ELSE
+      SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., ONLY_START=.TRUE.)//END_REC
+   ENDIF
+   SELF%INDENT = SELF%INDENT + 2
+   ENDSUBROUTINE WRITE_START_TAG
+
+   SUBROUTINE WRITE_TAG(SELF, NAME, ATTRIBUTES, CONTENT)
+   !< WRITE `<TAG_NAME...>...</TAG_NAME>` TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF       !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: NAME       !< TAG NAME.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: ATTRIBUTES !< TAG ATTRIBUTES.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: CONTENT    !< TAG CONTENT.
+
+   SELF%TAG = XML_TAG(NAME=NAME, ATTRIBUTES_STREAM=ATTRIBUTES, SANITIZE_ATTRIBUTES_VALUE=.TRUE., CONTENT=CONTENT, &
+                      INDENT=SELF%INDENT)
+   IF (.NOT.SELF%IS_VOLATILE) THEN
+      CALL SELF%TAG%WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR, IS_INDENTED=.TRUE., IS_CONTENT_INDENTED=.TRUE., END_RECORD=END_REC)
+   ELSE
+      SELF%XML_VOLATILE = SELF%XML_VOLATILE//SELF%TAG%STRINGIFY(IS_INDENTED=.TRUE., IS_CONTENT_INDENTED=.TRUE.)//END_REC
+   ENDIF
+   ENDSUBROUTINE WRITE_TAG
+
+   SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND)
+   !< WRITE XML TOPOLOGY TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF      !< WRITER.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX1       !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX2       !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY1       !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY2       !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ1       !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ2       !< FINAL NODE OF Z AXIS.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: MESH_KIND !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+   TYPE(STRING)                                     :: BUFFER    !< BUFFER STRING.
+
+   BUFFER = ''
+   SELECT CASE(SELF%TOPOLOGY%CHARS())
+   CASE('RectilinearGrid', 'StructuredGrid','ImageData')
+      BUFFER = 'WholeExtent="'//                             &
+               TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//&
+               TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//&
+               TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'"'
+   CASE('PRectilinearGrid', 'PStructuredGrid','PImageData')
+      BUFFER = 'WholeExtent="'//                             &
+               TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//&
+               TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//&
+               TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" GhostLevel="#"'
+   CASE('PUnstructuredGrid')
+      BUFFER = 'GhostLevel="0"'
+   ENDSELECT
+   CALL SELF%WRITE_START_TAG(NAME=SELF%TOPOLOGY%CHARS(), ATTRIBUTES=BUFFER%CHARS())
+   ! PARALLEL TOPOLOGIES PECULIARS
+   SELECT CASE(SELF%TOPOLOGY%CHARS())
+   CASE('PRectilinearGrid')
+      IF (.NOT.PRESENT(MESH_KIND)) THEN
+         SELF%ERROR = 1
+         RETURN
+      ENDIF
+      CALL SELF%WRITE_START_TAG(NAME='PCoordinates')
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"')
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"')
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"')
+      CALL SELF%WRITE_END_TAG(NAME='PCoordinates')
+   CASE('PStructuredGrid', 'PUnstructuredGrid')
+      IF (.NOT.PRESENT(MESH_KIND)) THEN
+         SELF%ERROR = 1
+         RETURN
+      ENDIF
+      CALL SELF%WRITE_START_TAG(NAME='PPoints')
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', &
+                                       ATTRIBUTES='type="'//TRIM(MESH_KIND)//'" NumberOfComponents="3" NAME="POINTS"')
+      CALL SELF%WRITE_END_TAG(NAME='PPoints')
+   ENDSELECT
+   ENDSUBROUTINE WRITE_TOPOLOGY_TAG
+
+   ! W_DATA
+   SUBROUTINE W_DATA_TAG(SELF, DATA_TYPE, NUMBER_OF_COMPONENTS, DATA_NAME, DATA_CONTENT, IS_TUPLES)
+   !< WRITE `<DATAARRAY...>...</DATAARRAY>` TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF                 !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: DATA_TYPE            !< TYPE OF DATAARRAY.
+   INTEGER(I4P),               INTENT(IN)           :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS.
+   CHARACTER(*),               INTENT(IN)           :: DATA_NAME            !< DATA NAME.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: DATA_CONTENT         !< DATA CONTENT.
+   LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES            !< USE "NUMBEROFTUPLES".
+   TYPE(STRING)                                     :: TAG_ATTRIBUTES       !< TAG ATTRIBUTES.
+   LOGICAL                                          :: IS_TUPLES_           !< USE "NUMBEROFTUPLES".
+
+   IS_TUPLES_ = .FALSE.
+   IF (PRESENT(IS_TUPLES)) IS_TUPLES_ = IS_TUPLES
+   IF (IS_TUPLES_) THEN
+      TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//             &
+        '" NumberOfTuples="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// &
+        '" Name="'//TRIM(ADJUSTL(DATA_NAME))//                          &
+        '" format="'//SELF%FORMAT_CH//'"'
+   ELSE
+      TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//                 &
+        '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// &
+        '" Name="'//TRIM(ADJUSTL(DATA_NAME))//                              &
+        '" format="'//SELF%FORMAT_CH//'"'
+   ENDIF
+   CALL SELF%WRITE_TAG(NAME='DataArray', ATTRIBUTES=TAG_ATTRIBUTES%CHARS(), CONTENT=DATA_CONTENT)
+   ENDSUBROUTINE W_DATA_TAG
+
+   SUBROUTINE W_DATA_TAG_APPENDED(SELF, DATA_TYPE, NUMBER_OF_COMPONENTS, DATA_NAME, IS_TUPLES)
+   !< WRITE `<DATAARRAY.../>` TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF                 !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: DATA_TYPE            !< TYPE OF DATAARRAY.
+   INTEGER(I4P),               INTENT(IN)           :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS.
+   CHARACTER(*),               INTENT(IN)           :: DATA_NAME            !< DATA NAME.
+   LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES            !< USE "NUMBEROFTUPLES".
+   TYPE(STRING)                                     :: TAG_ATTRIBUTES       !< TAG ATTRIBUTES.
+   LOGICAL                                          :: IS_TUPLES_           !< USE "NUMBEROFTUPLES".
+
+   IS_TUPLES_ = .FALSE.
+   IF (PRESENT(IS_TUPLES)) IS_TUPLES_ = IS_TUPLES
+   IF (IS_TUPLES_) THEN
+      TAG_ATTRIBUTES =  'type="'//TRIM(ADJUSTL(DATA_TYPE))//            &
+        '" NumberOfTuples="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// &
+        '" Name="'//TRIM(ADJUSTL(DATA_NAME))//                          &
+        '" format="'//SELF%FORMAT_CH//                                  &
+        '" offset="'//TRIM(STR(SELF%IOFFSET, .TRUE.))//'"'
+   ELSE
+      TAG_ATTRIBUTES = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//                 &
+        '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))// &
+        '" Name="'//TRIM(ADJUSTL(DATA_NAME))//                              &
+        '" format="'//SELF%FORMAT_CH//                                      &
+        '" offset="'//TRIM(STR(SELF%IOFFSET, .TRUE.))//'"'
+   ENDIF
+   CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='DataArray', ATTRIBUTES=TAG_ATTRIBUTES%CHARS())
+   ENDSUBROUTINE W_DATA_TAG_APPENDED
+
+   FUNCTION W_DATA_LOCATION_TAG(SELF, LOCATION, ACTION) RESULT(ERROR)
+   !< WRITE `<[/]POINTDATA>` OR `<[/]CELLDATA>` OPEN/CLOSE TAG.
+   !<
+   !< @NOTE **MUST** BE CALLED BEFORE SAVING THE DATA RELATED TO GEOMETRIC MESH, THIS FUNCTION INITIALIZES THE
+   !< SAVING OF DATA VARIABLES INDICATING THE *LOCATION* (NODE OR CELL CENTERED) OF VARIABLES THAT WILL BE SAVED.
+   !<
+   !< @NOTE A SINGLE FILE CAN CONTAIN BOTH CELL AND NODE CENTERED VARIABLES. IN THIS CASE THE VTK_DAT_XML FUNCTION MUST BE
+   !< CALLED TWO TIMES, BEFORE SAVING CELL-CENTERED VARIABLES AND BEFORE SAVING NODE-CENTERED VARIABLES.
+   !<
+   !<### EXAMPLES OF USAGE
+   !<
+   !<#### OPENING NODE PIECE
+   !<```FORTRAN
+   !< ERROR = VTK%W_DATA('NODE','OPEN')
+   !<```
+   !<
+   !<#### CLOSING NODE PIECE
+   !<```FORTRAN
+   !< ERROR = VTK%W_DATA('NODE','CLOSE')
+   !<```
+   !<
+   !<#### OPENING CELL PIECE
+   !<```FORTRAN
+   !< ERROR = VTK%W_DATA('CELL','OPEN')
+   !<```
+   !<
+   !<#### CLOSING CELL PIECE
+   !<```FORTRAN
+   !< ERROR = VTK%W_DATA('CELL','CLOSE')
+   !<```
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF      !< WRITER.
+   CHARACTER(*),               INTENT(IN)    :: LOCATION  !< LOCATION OF VARIABLES: **CELL** OR **NODE** CENTERED.
+   CHARACTER(*),               INTENT(IN)    :: ACTION    !< ACTION: **OPEN** OR **CLOSE** TAG.
+   INTEGER(I4P)                              :: ERROR     !< ERROR STATUS.
+   TYPE(STRING)                              :: LOCATION_ !< LOCATION STRING.
+   TYPE(STRING)                              :: ACTION_   !< ACTION STRING.
+
+   LOCATION_ = TRIM(ADJUSTL(LOCATION)) ; LOCATION_ = LOCATION_%UPPER()
+   ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER()
+   SELECT CASE(LOCATION_%CHARS())
+   CASE('CELL')
+      LOCATION_ = 'CellData'
+   CASE('NODE')
+      LOCATION_ = 'PointData'
+   ENDSELECT
+   SELECT CASE(SELF%TOPOLOGY%CHARS())
+   CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid')
+      LOCATION_ = 'P'//LOCATION_
+   ENDSELECT
+   SELECT CASE(ACTION_%CHARS())
+   CASE('OPEN')
+      CALL SELF%WRITE_START_TAG(NAME=LOCATION_%CHARS())
+   CASE('CLOSE')
+      CALL SELF%WRITE_END_TAG(NAME=LOCATION_%CHARS())
+   ENDSELECT
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA_LOCATION_TAG
+
+   ! WRITE_FIELDDATA METHODS
+   FUNCTION WRITE_FIELDDATA1_RANK0(SELF, DATA_NAME, X) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NUMBEROFTUPLES="..."...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF      !< WRITER.
+   CHARACTER(*),               INTENT(IN)    :: DATA_NAME !< DATA NAME.
+   CLASS(*),                   INTENT(IN)    :: X         !< DATA VARIABLE.
+   INTEGER(I4P)                              :: ERROR     !< ERROR STATUS.
+
+   SELECT TYPE(X)
+   TYPE IS(REAL(R8P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   TYPE IS(REAL(R4P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   TYPE IS(INTEGER(I8P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   TYPE IS(INTEGER(I4P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   TYPE IS(INTEGER(I2P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   TYPE IS(INTEGER(I1P))
+      SELF%ERROR = SELF%W_DATA(DATA_NAME=DATA_NAME, X=[X], IS_TUPLES=.TRUE.)
+   ENDSELECT
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_FIELDDATA1_RANK0
+
+   FUNCTION WRITE_FIELDDATA_TAG(SELF, ACTION) RESULT(ERROR)
+   !< WRITE `<FIELDDATA>`/`</FIELDDATA>` START/END TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF      !< WRITER.
+   CHARACTER(*),               INTENT(IN)    :: ACTION    !< ACTION: **OPEN** OR **CLOSE** TAG.
+   INTEGER(I4P)                              :: ERROR     !< ERROR STATUS.
+   TYPE(STRING)                              :: ACTION_   !< ACTION STRING.
+
+   ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER()
+   SELECT CASE(ACTION_%CHARS())
+   CASE('OPEN')
+      CALL SELF%WRITE_START_TAG(NAME='FieldData')
+   CASE('CLOSE')
+      CALL SELF%WRITE_END_TAG(NAME='FieldData')
+   ENDSELECT
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_FIELDDATA_TAG
+
+   ! WRITE_PIECE METHODS
+   FUNCTION WRITE_PIECE_START_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR)
+   !< WRITE `<PIECE ...>` START TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF           !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NX1            !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN)    :: NX2            !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN)    :: NY1            !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN)    :: NY2            !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN)    :: NZ1            !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),               INTENT(IN)    :: NZ2            !< FINAL NODE OF Z AXIS.
+   INTEGER(I4P)                              :: ERROR          !< ERROR STATUS.
+   TYPE(STRING)                              :: TAG_ATTRIBUTES !< TAG ATTRIBUTES.
+
+   TAG_ATTRIBUTES = 'Extent="'//TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// &
+                                TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// &
+                                TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'"'
+   CALL SELF%WRITE_START_TAG(NAME='Piece', ATTRIBUTES=TAG_ATTRIBUTES%CHARS())
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PIECE_START_TAG
+
+   FUNCTION WRITE_PIECE_START_TAG_UNST(SELF, NP, NC) RESULT(ERROR)
+   !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF           !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP             !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC             !< NUMBER OF CELLS.
+   INTEGER(I4P)                              :: ERROR          !< ERROR STATUS.
+   TYPE(STRING)                              :: TAG_ATTRIBUTES !< TAG ATTRIBUTES.
+
+   TAG_ATTRIBUTES = 'NumberOfPoints="'//TRIM(STR(N=NP))//'" NumberOfCells="'//TRIM(STR(N=NC))//'"'
+   CALL SELF%WRITE_START_TAG(NAME='Piece', ATTRIBUTES=TAG_ATTRIBUTES%CHARS())
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PIECE_START_TAG_UNST
+
+   FUNCTION WRITE_PIECE_END_TAG(SELF) RESULT(ERROR)
+   !< WRITE `</PIECE>` END TAG.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_END_TAG(NAME='Piece')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PIECE_END_TAG
+
+   ! WRITE_GEO_RECT METHODS
+   FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R8P(SELF, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **RECTILINEARGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Coordinates')
+   ERROR = SELF%W_DATA(DATA_NAME='X', X=X)
+   ERROR = SELF%W_DATA(DATA_NAME='Y', X=Y)
+   ERROR = SELF%W_DATA(DATA_NAME='Z', X=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Coordinates')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R8P
+
+   FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P(SELF, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **RECTILINEARGRID** TOPOLOGY (DATA 3, RANK 1, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   REAL(R4P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Coordinates')
+   ERROR = SELF%W_DATA(DATA_NAME='X', X=X)
+   ERROR = SELF%W_DATA(DATA_NAME='Y', X=Y)
+   ERROR = SELF%W_DATA(DATA_NAME='Z', X=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Coordinates')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P
+
+   ! WRITE_GEO_STRG METHODS
+   FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P(SELF, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,1:N].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P
+
+   FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P(SELF, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P
+
+   FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P(SELF, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF             !< WRITER.
+   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:].
+   INTEGER(I4P)                              :: ERROR            !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P
+
+   FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P(SELF, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF             !< WRITER.
+   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:].
+   INTEGER(I4P)                              :: ERROR            !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P
+
+   FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: N     !< NUMBER OF NODES.
+   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P
+
+   FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P(SELF, N, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: N     !< NUMBER OF NODES.
+   REAL(R4P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P
+
+   FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P(SELF, N, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF        !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: N           !< NUMBER OF NODES.
+   REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR       !< ERROR STATUS.
+
+   IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.&
+       (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.&
+       (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P
+
+   FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P(SELF, N, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF        !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: N           !< NUMBER OF NODES.
+   REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR       !< ERROR STATUS.
+
+   IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.&
+       (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.&
+       (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P
+
+   ! WRITE_GEO_UNST METHODS
+   FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
+   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   IF (NP/=SIZE(XYZ, DIM=2)) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P
+
+   FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
+   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   IF (NP/=SIZE(XYZ, DIM=2)) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P
+
+   FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP    !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC    !< NUMBER OF CELLS.
+   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P
+
+   FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP    !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC    !< NUMBER OF CELLS.
+   REAL(R4P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P
+
+   FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FACEOFFSET) RESULT(ERROR)
+   !< WRITE MESH CONNECTIVITY.
+   !<
+   !< **MUST** BE USED WHEN UNSTRUCTURED GRID IS USED, IT SAVES THE CONNECTIVITY OF THE UNSTRUCTURED GIRD.
+   !< @NOTE THE VECTOR **CONNECT** MUST FOLLOW THE VTK-XML STANDARD. IT IS PASSED AS *ASSUMED-SHAPE ARRAY*
+   !< BECAUSE ITS DIMENSIONS IS RELATED TO THE MESH DIMENSIONS IN A COMPLEX WAY. ITS DIMENSIONS CAN BE CALCULATED BY THE FOLLOWING
+   !< EQUATION: \(DC = \SUM\LIMITS_{I = 1}^{NC} {NVERTEX_I }\).
+   !< NOTE THAT THIS EQUATION IS DIFFERENT FROM THE LEGACY ONE. THE XML CONNECTIVITY CONVENTION IS QUITE DIFFERENT FROM THE
+   !< LEGACY STANDARD.
+   !< AS AN EXAMPLE SUPPOSE WE HAVE A MESH COMPOSED BY 2 CELLS, ONE HEXAHEDRON (8 VERTICES) AND ONE PYRAMID WITH
+   !< SQUARE BASIS (5 VERTICES) AND SUPPOSE THAT THE BASIS OF PYRAMID IS CONSTITUTE BY A FACE OF THE HEXAHEDRON AND SO THE TWO CELLS
+   !< SHARE 4 VERTICES. THE ABOVE EQUATION GIVES \(DC=8+5=13\). THE CONNECTIVITY VECTOR FOR THIS MESH CAN BE:
+   !<
+   !<##### FIRST CELL
+   !<+ CONNECT(1)  = 0 IDENTIFICATION FLAG OF \(1^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(2)  = 1 IDENTIFICATION FLAG OF \(2^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(3)  = 2 IDENTIFICATION FLAG OF \(3^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(4)  = 3 IDENTIFICATION FLAG OF \(4^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(5)  = 4 IDENTIFICATION FLAG OF \(5^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(6)  = 5 IDENTIFICATION FLAG OF \(6^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(7)  = 6 IDENTIFICATION FLAG OF \(7^\CIRC\) VERTEX OF FIRST CELL
+   !<+ CONNECT(8)  = 7 IDENTIFICATION FLAG OF \(8^\CIRC\) VERTEX OF FIRST CELL
+   !<
+   !<##### SECOND CELL
+   !<+ CONNECT(9 ) = 0 IDENTIFICATION FLAG OF \(1^\CIRC\) VERTEX OF SECOND CELL
+   !<+ CONNECT(10) = 1 IDENTIFICATION FLAG OF \(2^\CIRC\) VERTEX OF SECOND CELL
+   !<+ CONNECT(11) = 2 IDENTIFICATION FLAG OF \(3^\CIRC\) VERTEX OF SECOND CELL
+   !<+ CONNECT(12) = 3 IDENTIFICATION FLAG OF \(4^\CIRC\) VERTEX OF SECOND CELL
+   !<+ CONNECT(13) = 8 IDENTIFICATION FLAG OF \(5^\CIRC\) VERTEX OF SECOND CELL
+   !<
+   !< THEREFORE THIS CONNECTIVITY VECTOR CONVENTION IS MORE SIMPLE THAN THE LEGACY CONVENTION, NOW WE MUST CREATE ALSO THE
+   !< *OFFSET* VECTOR THAT CONTAINS THE DATA NOW MISSING IN THE *CONNECT* VECTOR. THE OFFSET
+   !< VECTOR FOR THIS MESH CAN BE:
+   !<
+   !<##### FIRST CELL
+   !<+ OFFSET(1) = 8  => SUMM OF NODES OF \(1^\CIRC\) CELL
+   !<
+   !<##### SECOND CELL
+   !<+ OFFSET(2) = 13 => SUMM OF NODES OF \(1^\CIRC\) AND \(2^\CIRC\) CELLS
+   !<
+   !< THE VALUE OF EVERY CELL-OFFSET CAN BE CALCULATED BY THE FOLLOWING EQUATION: \(OFFSET_C=\SUM\LIMITS_{I=1}^{C}{NVERTEX_I}\)
+   !< WHERE \(OFFSET_C\) IS THE VALUE OF \(C^{TH}\) CELL AND \(NVERTEX_I\) IS THE NUMBER OF VERTICES OF \(I^{TH}\) CELL.
+   !< THE FUNCTION VTK_CON_XML DOES NOT CALCULATE THE CONNECTIVITY AND OFFSET VECTORS: IT WRITES THE CONNECTIVITY AND OFFSET
+   !< VECTORS CONFORMING THE VTK-XML STANDARD, BUT DOES NOT CALCULATE THEM.
+   !< THE VECTOR VARIABLE *CELL\_TYPE* MUST CONFORM THE VTK-XML STANDARD (SEE THE FILE VTK-STANDARD AT THE
+   !< KITWARE HOMEPAGE) THAT IS THE SAME OF THE LEGACY STANDARD. IT CONTAINS THE
+   !< *TYPE* OF EACH CELLS. FOR THE ABOVE EXAMPLE THIS VECTOR IS:
+   !<
+   !<##### FIRST CELL
+   !<+ CELL\_TYPE(1) = 12 HEXAHEDRON TYPE OF FIRST CELL
+   !<
+   !<##### SECOND CELL
+   !<+ CELL\_TYPE(2) = 14 PYRAMID TYPE OF SECOND CELL
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF             !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NC               !< NUMBER OF CELLS.
+   INTEGER(I4P),               INTENT(IN)    :: CONNECTIVITY(1:) !< MESH CONNECTIVITY.
+   INTEGER(I4P),               INTENT(IN)    :: OFFSET(1:)       !< CELL OFFSET.
+   INTEGER(I4P),   OPTIONAL,   INTENT(IN)    :: FACE(1:)         !< FACE COMPOSING THE POLYHEDRA.
+   INTEGER(I4P),   OPTIONAL,   INTENT(IN)    :: FACEOFFSET(1:)   !< FACE OFFSET.
+   INTEGER(I1P),               INTENT(IN)    :: VTKC_TYPE(1:)    !< VTK CELL TYPE.
+   INTEGER(I4P)                              :: ERROR            !< ERROR STATUS.
+
+   CALL SELF%WRITE_START_TAG(NAME='Cells')
+   ERROR = SELF%W_DATA(DATA_NAME='connectivity', X=CONNECTIVITY)
+   ERROR = SELF%W_DATA(DATA_NAME='offsets', X=OFFSET)
+   ERROR = SELF%W_DATA(DATA_NAME='types', X=VTKC_TYPE)
+   CALL SELF%WRITE_END_TAG(NAME='Cells')
+
+   !< ADD FACES AND FACEOFFSETS TO THE CELL BLOCK FOR POLYHEDRA. IF THE CELL IS NOT A POLYHEDRON, ITS OFFSET MUST BE SET TO -1.
+   IF(PRESENT(FACE).AND. PRESENT(FACEOFFSET)) THEN
+        ERROR = SELF%W_DATA(DATA_NAME='Faces', X=FACE)
+        ERROR = SELF%W_DATA(DATA_NAME='FaceOffsets', X=FACEOFFSET)
+   ENDIF
+   ENDFUNCTION WRITE_CONNECTIVITY
+
+   ! WRITE_PARALLEL METHODS
+   FUNCTION WRITE_PARALLEL_OPEN_BLOCK(SELF, NAME) RESULT(ERROR)
+   !< WRITE A BLOCK (OPEN) CONTAINER.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF   !< WRITER.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: NAME   !< BLOCK NAME.
+   INTEGER(I4P)                                     :: ERROR  !< ERROR STATUS.
+   TYPE(STRING)                                     :: BUFFER !< BUFFER STRING.
+
+   SELF%VTM_BLOCK = SELF%VTM_BLOCK + 1
+   IF (PRESENT(NAME)) THEN
+      BUFFER = 'Index="'//TRIM(STR((SELF%VTM_BLOCK(1) + SELF%VTM_BLOCK(2)),.TRUE.))//'" Name="'//TRIM(ADJUSTL(NAME))//'"'
+   ELSE
+      BUFFER = 'Index="'//TRIM(STR((SELF%VTM_BLOCK(1) + SELF%VTM_BLOCK(2)),.TRUE.))//'"'
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Block', ATTRIBUTES=BUFFER%CHARS())
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_OPEN_BLOCK
+
+   FUNCTION WRITE_PARALLEL_CLOSE_BLOCK(SELF) RESULT(ERROR)
+   !< CLOSE A BLOCK CONTAINER.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   SELF%VTM_BLOCK(2) = -1
+   CALL SELF%WRITE_END_TAG(NAME='Block')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_CLOSE_BLOCK
+
+   FUNCTION WRITE_PARALLEL_DATAARRAY(SELF, DATA_NAME, DATA_TYPE, NUMBER_OF_COMPONENTS) RESULT(ERROR)
+   !< WRITE PARALLEL (PARTITIONED) VTK-XML DATAARRAY INFO.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF                 !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: DATA_NAME            !< DATA NAME.
+   CHARACTER(*),               INTENT(IN)           :: DATA_TYPE            !< TYPE OF DATAARRAY.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NUMBER_OF_COMPONENTS !< NUMBER OF DATAARRAY COMPONENTS.
+   INTEGER(I4P)                                     :: ERROR                !< ERROR STATUS.
+   TYPE(STRING)                                     :: BUFFER               !< BUFFER STRING.
+
+   IF (PRESENT(NUMBER_OF_COMPONENTS)) THEN
+      BUFFER = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//'" Name="'//TRIM(ADJUSTL(DATA_NAME))//&
+               '" NumberOfComponents="'//TRIM(STR(NUMBER_OF_COMPONENTS, .TRUE.))//'"'
+   ELSE
+      BUFFER = 'type="'//TRIM(ADJUSTL(DATA_TYPE))//'" Name="'//TRIM(ADJUSTL(DATA_NAME))//'"'
+   ENDIF
+   CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES=BUFFER%CHARS())
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_DATAARRAY
+
+   FUNCTION WRITE_PARALLEL_GEO(SELF, SOURCE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR)
+   !< WRITE PARALLEL (PARTITIONED) VTK-XML GEO SOURCE FILE.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF   !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: SOURCE !< SOURCE FILE NAME CONTAINING THE PIECE DATA.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX1    !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX2    !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY1    !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY2    !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ1    !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ2    !< FINAL NODE OF Z AXIS.
+   INTEGER(I4P)                                     :: ERROR  !< ERROR STATUS.
+   TYPE(STRING)                                     :: BUFFER !< BUFFER STRING.
+
+   SELECT CASE (SELF%TOPOLOGY%CHARS())
+   CASE('PRectilinearGrid', 'PStructuredGrid')
+      BUFFER = 'Extent="'// &
+               TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// &
+               TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// &
+               TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" Source="'//TRIM(ADJUSTL(SOURCE))//'"'
+   CASE('PUnstructuredGrid')
+      BUFFER = 'Source="'//TRIM(ADJUSTL(SOURCE))//'"'
+   ENDSELECT
+   CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Piece', ATTRIBUTES=BUFFER%CHARS())
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_GEO
+
+   FUNCTION WRITE_PARALLEL_BLOCK_FILE(SELF, FILE_INDEX, FILENAME, NAME) RESULT(ERROR)
+   !< WRITE SINGLE FILE THAT BELONG TO THE CURRENT BLOCK.
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF       !< WRITER.
+   INTEGER(I4P),               INTENT(IN)           :: FILE_INDEX !< INDEX OF FILE IN THE LIST.
+   CHARACTER(*),               INTENT(IN)           :: FILENAME   !< WRAPPED FILE NAMES.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: NAME       !< NAMES ATTRIBUTED TO WRAPPED FILE.
+   INTEGER(I4P)                                     :: ERROR      !< ERROR STATUS.
+
+   IF (PRESENT(NAME)) THEN
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                                      &
+                                       ATTRIBUTES='Index="'//TRIM(STR(FILE_INDEX, .TRUE.))//&
+                                                 '" File="'//TRIM(ADJUSTL(FILENAME))//      &
+                                                 '" Name="'//TRIM(ADJUSTL(NAME))//'"')
+   ELSE
+      CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                                       &
+                                       ATTRIBUTES='Index="'//TRIM(STR(FILE_INDEX, .TRUE.))// &
+                                                 '" File="'//TRIM(ADJUSTL(FILENAME))//'"')
+   ENDIF
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_BLOCK_FILE
+
+   FUNCTION WRITE_PARALLEL_BLOCK_FILES_ARRAY(SELF, FILENAMES, NAMES) RESULT(ERROR)
+   !< WRITE LIST OF FILES THAT BELONG TO THE CURRENT BLOCK (LIST PASSED AS RANK 1 ARRAY).
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES=['FILE_1.VTS','FILE_2.VTS','FILE_3.VTU'])
+   !<```
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES=['FILE_1.VTS','FILE_2.VTS','FILE_3.VTU'],&
+   !<                                       NAMES=['BLOCK-BAR','BLOCK-FOO','BLOCK-BAZ'])
+   !<```
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: FILENAMES(:) !< LIST OF VTK-XML WRAPPED FILE NAMES.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: NAMES(:)     !< LIST NAMES ATTRIBUTED TO WRAPPED FILES.
+   INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+   INTEGER(I4P)                                     :: F            !< FILE COUNTER.
+
+   IF (PRESENT(NAMES)) THEN
+      IF (SIZE(NAMES, DIM=1)==SIZE(FILENAMES, DIM=1)) THEN
+         DO F=1, SIZE(FILENAMES, DIM=1)
+            CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                                     &
+                                             ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))//      &
+                                                       '" File="'//TRIM(ADJUSTL(FILENAMES(F)))// &
+                                                       '" Name="'//TRIM(ADJUSTL(NAMES(F)))//'"')
+         ENDDO
+      ENDIF
+   ELSE
+      DO F=1,SIZE(FILENAMES, DIM=1)
+         CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                                &
+                                          ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))// &
+                                                    '" File="'//TRIM(ADJUSTL(FILENAMES(F)))//'"')
+      ENDDO
+   ENDIF
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_BLOCK_FILES_ARRAY
+
+   FUNCTION WRITE_PARALLEL_BLOCK_FILES_STRING(SELF, FILENAMES, NAMES, DELIMITER) RESULT(ERROR)
+   !< WRITE LIST OF FILES THAT BELONG TO THE CURRENT BLOCK (LIST PASSED AS SINGLE STRING).
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU')
+   !<```
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_FILES_LIST_OF_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU',&
+   !<                                       NAMES='BLOCK-BAR BLOCK-FOO BLOCK-BAZ')
+   !<```
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),               INTENT(IN)           :: FILENAMES     !< LIST OF VTK-XML WRAPPED FILE NAMES.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: NAMES         !< LIST NAMES ATTRIBUTED TO WRAPPED FILES.
+   CHARACTER(*),               INTENT(IN), OPTIONAL :: DELIMITER     !< DELIMITER CHARACTER.
+   INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+   TYPE(STRING), ALLOCATABLE                        :: FILENAMES_(:) !< LIST OF VTK-XML WRAPPED FILE NAMES.
+   TYPE(STRING), ALLOCATABLE                        :: NAMES_(:)     !< LIST NAMES ATTRIBUTED TO WRAPPED FILES.
+   TYPE(STRING)                                     :: DELIMITER_    !< DELIMITER CHARACTER.
+   TYPE(STRING)                                     :: BUFFER        !< A STRING BUFFER.
+   INTEGER(I4P)                                     :: F             !< FILE COUNTER.
+
+   DELIMITER_ = ' ' ; IF (PRESENT(DELIMITER)) DELIMITER_ = DELIMITER
+   BUFFER = FILENAMES
+   CALL BUFFER%SPLIT(TOKENS=FILENAMES_, SEP=DELIMITER_%CHARS())
+   IF (PRESENT(NAMES)) THEN
+      BUFFER = NAMES
+      CALL BUFFER%SPLIT(TOKENS=NAMES_, SEP=DELIMITER_%CHARS())
+      IF (SIZE(NAMES_, DIM=1)==SIZE(FILENAMES_, DIM=1)) THEN
+         DO F=1, SIZE(FILENAMES_, DIM=1)
+            CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                                      &
+                                             ATTRIBUTES='Index="'//TRIM(STR(F-1, .TRUE.))//       &
+                                                       '" File="'//TRIM(ADJUSTL(FILENAMES_(F)))// &
+                                                       '" Name="'//TRIM(ADJUSTL(NAMES_(F)))//'"')
+         ENDDO
+      ENDIF
+   ELSE
+      DO F=1,SIZE(FILENAMES_, DIM=1)
+         CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Dataset',                               &
+                                          ATTRIBUTES='Index="'//TRIM(STR(F-1,.TRUE.))// &
+                                                    '" File="'//TRIM(ADJUSTL(FILENAMES_(F)))//'"')
+      ENDDO
+   ENDIF
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_PARALLEL_BLOCK_FILES_STRING
+ENDMODULE VTKF_FILE_XML_WRITER_ABSTRACT
+
+
+
+!< DATAARRAY ENCODER, CODECS: "ASCII", "BASE64".
+MODULE VTK_FORTRAN_DATAARRAY_ENCODER
+!< VTK FILE XML WRITER, ASCII LOCAL.
+USE BEFOR64
+USE PENF
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: ENCODE_ASCII_DATAARRAY
+PUBLIC :: ENCODE_BINARY_DATAARRAY
+
+INTERFACE ENCODE_ASCII_DATAARRAY
+  !< ASCII DATAARRAY ENCODER.
+  MODULE PROCEDURE ENCODE_ASCII_DATAARRAY1_RANK1_R8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK1_R4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK1_I8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK1_I4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK1_I2P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK1_I1P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_R8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_R4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_I8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_I4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_I2P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK2_I1P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_R8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_R4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_I8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_I4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_I2P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK3_I1P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_R8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_R4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_I8P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_I4P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_I2P, &
+                   ENCODE_ASCII_DATAARRAY1_RANK4_I1P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_R8P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_R4P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_I8P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_I4P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_I2P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK1_I1P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_R8P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_R4P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_I8P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_I4P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_I2P, &
+                   ENCODE_ASCII_DATAARRAY3_RANK3_I1P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_R8P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_R4P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_I8P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_I4P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_I2P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK1_I1P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_R8P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_R4P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_I8P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_I4P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_I2P, &
+                   ENCODE_ASCII_DATAARRAY6_RANK3_I1P
+ENDINTERFACE ENCODE_ASCII_DATAARRAY
+INTERFACE ENCODE_BINARY_DATAARRAY
+  !< BINARY (BASE64) DATAARRAY ENCODER.
+  MODULE PROCEDURE ENCODE_BINARY_DATAARRAY1_RANK1_R8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK1_R4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK1_I8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK1_I4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK1_I2P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK1_I1P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_R8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_R4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_I8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_I4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_I2P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK2_I1P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_R8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_R4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_I8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_I4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_I2P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK3_I1P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_R8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_R4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_I8P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_I4P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_I2P, &
+                   ENCODE_BINARY_DATAARRAY1_RANK4_I1P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_R8P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_R4P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_I8P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_I4P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_I2P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK1_I1P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_R8P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_R4P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_I8P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_I4P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_I2P, &
+                   ENCODE_BINARY_DATAARRAY3_RANK3_I1P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_R8P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_R4P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_I8P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_I4P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_I2P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK1_I1P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_R8P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_R4P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_I8P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_I4P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_I2P, &
+                   ENCODE_BINARY_DATAARRAY6_RANK3_I1P
+ENDINTERFACE ENCODE_BINARY_DATAARRAY
+CONTAINS
+  !< ASCII ENCODER
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R16P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P).
+  REAL(R16P),      INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DR16P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DR8P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DR4P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DI8P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DI4P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DI2P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION SIZE
+  
+  SIZE_N = SIZE(X,DIM=1)
+  L = DI1P+1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N = 1,SIZE_N
+      CODE(SP+1:SP+L) = STR(N=X(N))
+      SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R16P).
+  REAL(R16P),      INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DR16P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L 
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DR8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DR4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DI8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DI4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DI4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1       !< COUNTER.
+  INTEGER(I4P)                  :: N2       !< COUNTER.
+  INTEGER(I4P)                  :: L        !< LENGTH
+  INTEGER(I4P)                  :: SP       !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  L = DI1P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
+  DO N2=1, SIZE(X, DIM=2)
+    DO N1=1, SIZE(X, DIM=1)-1
+      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
+      SP = SP + L
+    ENDDO
+    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R16P).
+  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR16P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + 1
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH 
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI2P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI1P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)-1
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
+        SP = SP + L
+      ENDDO
+      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
+      SP = SP + L
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R16P).
+  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DR16P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DR8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DR4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DI8P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DI4P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DI2P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1             !< COUNTER.
+  INTEGER(I4P)                  :: N2             !< COUNTER.
+  INTEGER(I4P)                  :: N3             !< COUNTER.
+  INTEGER(I4P)                  :: N4             !< COUNTER.
+  INTEGER(I4P)                  :: L              !< LENGTH
+  INTEGER(I4P)                  :: SP             !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
+  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
+  
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  SIZE_N3 = SIZE(X, DIM=4)
+  
+  L = DI1P + 1
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
+  DO N4=1, SIZE(X, DIM=4)
+    DO N3=1, SIZE(X, DIM=3)
+      DO N2=1, SIZE(X, DIM=2)
+        DO N1=1, SIZE(X, DIM=1)
+          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
+          SP = SP + L
+        ENDDO
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R16P).
+  REAL(R16P),      INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR16P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+  
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR8P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR4P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI8P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+  
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI4P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I2P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI2P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI1P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
+  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR16P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR8P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR4P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI8P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI4P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI2P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI1P*3 + 2
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE(X, DIM=3)
+    DO N2=1, SIZE(X, DIM=2)
+      DO N1=1, SIZE(X, DIM=1)
+        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P
+  
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R16P).
+  REAL(R16P),      INTENT(IN)   :: U(1:) !< U COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: V(1:) !< V COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: W(1:) !< W COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+  
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR16P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P),       INTENT(IN)   :: U(1:) !< U COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: V(1:) !< V COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: W(1:) !< W COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR8P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P),       INTENT(IN)   :: U(1:) !< U COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: V(1:) !< V COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: W(1:) !< W COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DR4P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI8P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI4P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI2P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N     !< COUNTER.
+  INTEGER(I4P)                  :: L     !< LENGTH
+  INTEGER(I4P)                  :: SP    !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
+
+  SIZE_N = SIZE(X, DIM=1)
+  L = DI1P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N)
+  DO N=1, SIZE_N
+    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
+                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
+    SP = SP + L
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
+  REAL(R16P),      INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R16P),      INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR16P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P),       INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR8P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P),       INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DR4P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI8P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI4P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI2P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P
+
+  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+  INTEGER(I4P)                  :: L           !< LENGTH
+  INTEGER(I4P)                  :: SP          !< STRING POINTER
+  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
+  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
+  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
+
+  SIZE_N1 = SIZE(X, DIM=1)
+  SIZE_N2 = SIZE(X, DIM=2)
+  SIZE_N3 = SIZE(X, DIM=3)
+  
+  L = DI1P*6 + 5
+  SP = 0
+  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
+  DO N3=1, SIZE_N3
+    DO N2=1, SIZE_N2
+      DO N1=1, SIZE_N1
+        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
+          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
+        SP = SP + L
+      ENDDO
+    ENDDO
+  ENDDO
+  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P
+
+  !< BINARY ENCODER
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P), INTENT(IN)         :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P), INTENT(IN)         :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN    !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P).
+  REAL(R8P), INTENT(IN)         :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P).
+  REAL(R4P), INTENT(IN)         :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
+  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P), INTENT(IN)         :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P), INTENT(IN)         :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P).
+  REAL(R8P), INTENT(IN)         :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P).
+  REAL(R4P), INTENT(IN)         :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P(X) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
+  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
+  CALL B64_ENCODE(N=XP, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(X(N), Y(N), Z(N), N=1, NN)]], XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I2P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                         N2=1, NN2),  &
+                                                                                         N3=1, NN3)]], XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P
+  
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
+  REAL(R8P),    INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
+  REAL(R4P),    INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)]], XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
+  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N      !< COUNTER.
+
+  NN = SIZE(X, DIM=1)
+  CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ, CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
+  REAL(R8P),    INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P).
+  REAL(R4P),    INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
+  INTEGER(I8P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
+  INTEGER(I4P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                            X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                         N2=1, NN2),  &
+                                                                                         N3=1, NN3)]], XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
+  INTEGER(I2P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P
+
+  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE)
+  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
+  INTEGER(I1P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
+  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
+  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
+  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
+  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
+  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
+  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
+  INTEGER(I4P)                  :: N1          !< COUNTER.
+  INTEGER(I4P)                  :: N2          !< COUNTER.
+  INTEGER(I4P)                  :: N3          !< COUNTER.
+
+  NN1 = SIZE(X, DIM=1)
+  NN2 = SIZE(X, DIM=2)
+  NN3 = SIZE(X, DIM=3)
+  NN = NN1*NN2*NN3
+  CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
+                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
+                                                                                                N2=1, NN2),  &
+                                                                                                N3=1, NN3)], &
+                 PACKED=XYZ)
+  CALL B64_ENCODE(N=XYZ,CODE=CODE)
+  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P
+ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER
+
+
+
+!< VTK FILE XML WRITER, ASCII LOCAL.
+MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+!< VTK FILE XML WRITER, ASCII LOCAL.
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_DATAARRAY_ENCODER
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_ASCII_LOCAL
+
+TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_ASCII_LOCAL
+  !< VTK FILE XML WRITER, ASCII LOCAL.
+  CONTAINS
+    ! DEFERRED METHODS
+    PROCEDURE, PASS(SELF) :: INITIALIZE                 !< INITIALIZE WRITER.
+    PROCEDURE, PASS(SELF) :: FINALIZE                   !< FINALIZE WRITER.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
+ENDTYPE XML_WRITER_ASCII_LOCAL
+CONTAINS
+  FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
+                      IS_VOLATILE, MESH_KIND) RESULT(ERROR)
+  !< INITIALIZE WRITER.
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: FORMAT        !< FILE FORMAT: ASCII.
+  CHARACTER(*),                  INTENT(IN)           :: FILENAME      !< FILE NAME.
+  CHARACTER(*),                  INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+  INTEGER(I4P),                  INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+  CHARACTER(*),                  INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+
+  SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
+  SELF%FORMAT_CH = FORMAT
+  SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER()
+  CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME)
+  CALL SELF%WRITE_HEADER_TAG
+  CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
+  ERROR = SELF%ERROR
+  ENDFUNCTION INITIALIZE
+
+   FUNCTION FINALIZE(SELF) RESULT(ERROR)
+   !< FINALIZE WRITER.
+   CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                                 :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS())
+   CALL SELF%WRITE_END_TAG(NAME='VTKFile')
+   CALL SELF%CLOSE_XML_FILE
+   ERROR = SELF%ERROR
+   ENDFUNCTION FINALIZE
+
+  ! W_DATA METHODS
+  FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_R8P
+
+  FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_R4P
+
+  FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I8P
+
+  FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I4P
+
+  FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I2P
+
+  FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 1
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I1P
+
+  FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_R8P
+
+  FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_R4P
+
+  FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I8P
+
+  FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I4P
+
+  FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I2P
+
+  FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I1P
+
+  FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_R8P
+
+  FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_R4P
+
+  FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I8P
+
+  FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I4P
+
+  FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I2P
+
+  FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I1P
+
+  FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_R8P
+
+  FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_R4P
+
+  FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I8P
+
+  FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I4P
+
+  FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I2P
+
+  FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CODE = ENCODE_ASCII_DATAARRAY(X=X)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I1P
+
+  FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_R8P
+
+  FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_R4P
+
+  FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I8P
+
+  FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I4P
+
+  FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I2P
+
+  FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I1P
+
+  FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_R8P
+
+  FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_R4P
+
+  FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I8P
+
+  FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I4P
+
+  FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I2P
+
+  FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 3
+  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I1P
+
+  FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_R8P
+
+  FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W,X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_R4P
+
+  FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I8P
+
+  FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I4P
+
+  FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I2P
+
+  FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I1P
+
+  FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                     INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_R8P
+
+  FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                     INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_R4P
+
+  FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I8P
+
+  FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I4P
+
+  FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I2P
+
+  FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 6
+  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                IS_TUPLES=IS_TUPLES)
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I1P
+
+  
+  SUBROUTINE W_DATA_APPENDED(SELF)
+  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
+  ENDSUBROUTINE W_DATA_APPENDED
+ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+
+
+
+
+
+
+!< VTK FILE XML WRITER, APPENDED.
+MODULE VTKF_FILE_XML_WRITER_APPENDED
+!< VTK FILE XML WRITER, APPENDED.
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_DATAARRAY_ENCODER
+USE VTK_FORTRAN_PARAMETERS
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_APPENDED
+
+TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_APPENDED
+  !< VTK FILE XML WRITER, APPENDED.
+  TYPE(STRING) :: ENCODING      !< APPENDED DATA ENCODING: "RAW" OR "BASE64".
+  INTEGER(I4P) :: SCRATCH=0_I4P !< SCRATCH LOGICAL UNIT.
+  CONTAINS
+    ! DEFERRED METHODS
+    PROCEDURE, PASS(SELF) :: INITIALIZE                 !< INITIALIZE WRITER.
+    PROCEDURE, PASS(SELF) :: FINALIZE                   !< FINALIZE WRITER.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
+    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
+    PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
+    ! PRIVATE METHODS
+    PROCEDURE, PASS(SELF), PRIVATE :: IOFFSET_UPDATE     !< UPDATE IOFFSET COUNT.
+    PROCEDURE, PASS(SELF), PRIVATE :: OPEN_SCRATCH_FILE  !< OPEN SCRATCH FILE.
+    PROCEDURE, PASS(SELF), PRIVATE :: CLOSE_SCRATCH_FILE !< CLOSE SCRATCH FILE.
+    GENERIC, PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY =>          &
+                        WRITE_ON_SCRATCH_DATAARRAY1_RANK1,     &
+                        WRITE_ON_SCRATCH_DATAARRAY1_RANK2,     &
+                        WRITE_ON_SCRATCH_DATAARRAY1_RANK3,     &
+                        WRITE_ON_SCRATCH_DATAARRAY1_RANK4,     &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P, &
+                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK1     !< WRITE DATAARRAY, DATA 1 RANK 1.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK2     !< WRITE DATAARRAY, DATA 1 RANK 2.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK3     !< WRITE DATAARRAY, DATA 1 RANK 3.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK4     !< WRITE DATAARRAY, DATA 1 RANK 4.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P !< WRITE DATAARRAY, COMP 3 RANK 1, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P !< WRITE DATAARRAY, COMP 3 RANK 1, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P !< WRITE DATAARRAY, COMP 3 RANK 1, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P !< WRITE DATAARRAY, COMP 3 RANK 1, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P !< WRITE DATAARRAY, COMP 3 RANK 1, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P !< WRITE DATAARRAY, COMP 3 RANK 1, I1P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P !< WRITE DATAARRAY, COMP 3 RANK 2, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P !< WRITE DATAARRAY, COMP 3 RANK 2, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P !< WRITE DATAARRAY, COMP 3 RANK 2, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P !< WRITE DATAARRAY, COMP 3 RANK 2, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P !< WRITE DATAARRAY, COMP 3 RANK 2, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P !< WRITE DATAARRAY, COMP 3 RANK 2, I1P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P !< WRITE DATAARRAY, COMP 3 RANK 3, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P !< WRITE DATAARRAY, COMP 3 RANK 3, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P !< WRITE DATAARRAY, COMP 3 RANK 3, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P !< WRITE DATAARRAY, COMP 3 RANK 3, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P !< WRITE DATAARRAY, COMP 3 RANK 3, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P !< WRITE DATAARRAY, COMP 3 RANK 3, I1P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P !< WRITE DATAARRAY, COMP 6 RANK 1, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P !< WRITE DATAARRAY, COMP 6 RANK 1, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P !< WRITE DATAARRAY, COMP 6 RANK 1, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P !< WRITE DATAARRAY, COMP 6 RANK 1, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P !< WRITE DATAARRAY, COMP 6 RANK 1, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P !< WRITE DATAARRAY, COMP 6 RANK 1, I1P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P !< WRITE DATAARRAY, COMP 6 RANK 2, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P !< WRITE DATAARRAY, COMP 6 RANK 2, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P !< WRITE DATAARRAY, COMP 6 RANK 2, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P !< WRITE DATAARRAY, COMP 6 RANK 2, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P !< WRITE DATAARRAY, COMP 6 RANK 2, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P !< WRITE DATAARRAY, COMP 6 RANK 2, I1P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P !< WRITE DATAARRAY, COMP 6 RANK 3, R8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P !< WRITE DATAARRAY, COMP 6 RANK 3, R4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P !< WRITE DATAARRAY, COMP 6 RANK 3, I8P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P !< WRITE DATAARRAY, COMP 6 RANK 3, I4P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P !< WRITE DATAARRAY, COMP 6 RANK 3, I2P.
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY, COMP 6 RANK 3, I1P.
+ENDTYPE XML_WRITER_APPENDED
+CONTAINS
+  FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
+                      IS_VOLATILE, MESH_KIND) RESULT(ERROR)
+  !< INITIALIZE WRITER.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: FORMAT        !< FILE FORMAT: ASCII.
+  CHARACTER(*),               INTENT(IN)           :: FILENAME      !< FILE NAME.
+  CHARACTER(*),               INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+  INTEGER(I4P),               INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+  CHARACTER(*),               INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+
+  SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
+  SELF%FORMAT_CH = 'appended'
+  SELF%ENCODING = FORMAT
+  SELF%ENCODING = SELF%ENCODING%UPPER()
+  SELECT CASE(SELF%ENCODING%CHARS())
+  CASE('raw')
+    SELF%ENCODING = 'raw'
+  CASE('binary-appended')
+    SELF%ENCODING = 'base64'
+  ENDSELECT
+  CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME)
+  CALL SELF%WRITE_HEADER_TAG
+  CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
+  SELF%IOFFSET = 0
+  CALL SELF%OPEN_SCRATCH_FILE
+  ERROR = SELF%ERROR
+  ENDFUNCTION INITIALIZE
+
+   FUNCTION FINALIZE(SELF) RESULT(ERROR)
+   !< FINALIZE WRITER.
+   CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS())
+   CALL SELF%W_DATA_APPENDED
+   CALL SELF%WRITE_END_TAG(NAME='VTKFile')
+   CALL SELF%CLOSE_XML_FILE
+   CALL SELF%CLOSE_SCRATCH_FILE
+   ERROR = SELF%ERROR
+   ENDFUNCTION FINALIZE
+
+  ELEMENTAL SUBROUTINE IOFFSET_UPDATE(SELF, N_BYTE)
+  !< UPDATE IOFFSET COUNT.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF  !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: N_BYTE !< NUMBER OF BYTES SAVED.
+
+  IF (SELF%ENCODING=='raw') THEN
+    SELF%IOFFSET = SELF%IOFFSET + BYI4P + N_BYTE
+  ELSE
+    SELF%IOFFSET = SELF%IOFFSET + ((N_BYTE + BYI4P + 2_I4P)/3_I4P)*4_I4P
+  ENDIF
+  ENDSUBROUTINE IOFFSET_UPDATE
+
+  SUBROUTINE OPEN_SCRATCH_FILE(SELF)
+  !< OPEN SCRATCH FILE.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF  !< WRITER.
+
+  OPEN(NEWUNIT=SELF%SCRATCH, &
+       FORM='UNFORMATTED',   &
+       ACCESS='STREAM',      &
+       ACTION='READWRITE',   &
+       STATUS='SCRATCH',     &
+       IOSTAT=SELF%ERROR)
+  ENDSUBROUTINE OPEN_SCRATCH_FILE
+
+  SUBROUTINE CLOSE_SCRATCH_FILE(SELF)
+  !< CLOSE SCRATCH FILE.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF  !< WRITER.
+
+  CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  ENDSUBROUTINE CLOSE_SCRATCH_FILE
+
+  ! W_DATA METHODS
+  FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_R8P
+
+  FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_R4P
+
+  FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I8P
+
+  FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I4P
+
+  FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I2P
+
+  FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 1
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK1_I1P
+
+  FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_R8P
+
+  FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_R4P
+
+  FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I8P
+
+  FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I4P
+
+  FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I2P
+
+  FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK2_I1P
+
+  FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_R8P
+
+  FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_R4P
+
+  FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I8P
+
+  FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I4P
+
+  FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I2P
+
+  FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK3_I1P
+
+  FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_R8P
+
+  FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_R4P
+
+  FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I8P
+
+  FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I4P
+
+  FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I2P
+
+  FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = SIZE(X, DIM=1)
+  IF (PRESENT(ONE_COMPONENT)) THEN
+    IF (ONE_COMPONENT) N_COMPONENTS = 1
+  ENDIF
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA1_RANK4_I1P
+
+  FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE.
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_R8P
+
+  FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_R4P
+
+  FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I8P
+
+  FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I4P
+
+  FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I2P
+
+  FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK1_I1P
+
+  FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_R8P
+
+  FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_R4P
+
+  FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I8P
+
+  FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I4P
+
+  FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I2P
+
+  FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 3
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA3_RANK3_I1P
+  
+  FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE.
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_R8P
+
+  FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_R4P
+
+  FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I8P
+
+  FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I4P
+
+  FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I2P
+
+  FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK1_I1P
+
+  FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float64'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_R8P
+
+  FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Float32'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_R4P
+
+  FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I8P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int64'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I8P
+
+  FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I4P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int32'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I4P
+
+  FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I2P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int16'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I2P
+
+  FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  INTEGER(I1P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+
+  DATA_TYPE = 'Int8'
+  N_COMPONENTS = 6
+  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
+                                         IS_TUPLES=IS_TUPLES)
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
+  ERROR = SELF%ERROR
+  ENDFUNCTION W_DATA6_RANK3_I1P
+
+  SUBROUTINE W_DATA_APPENDED(SELF)
+  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF              !< WRITER.
+  TYPE(STRING)                              :: TAG_ATTRIBUTES    !< TAG ATTRIBUTES.
+  INTEGER(I4P)                              :: N_BYTE            !< BYTES COUNT.
+  CHARACTER(LEN=2)                          :: DATAARRAY_TYPE    !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1.
+  INTEGER(I4P)                              :: DATAARRAY_DIM     !< DATAARRAY DIMENSION.
+  REAL(R8P),    ALLOCATABLE                 :: DATAARRAY_R8P(:)  !< DATAARRAY BUFFER OF R8P.
+  REAL(R4P),    ALLOCATABLE                 :: DATAARRAY_R4P(:)  !< DATAARRAY BUFFER OF R4P.
+  INTEGER(I8P), ALLOCATABLE                 :: DATAARRAY_I8P(:)  !< DATAARRAY BUFFER OF I8P.
+  INTEGER(I4P), ALLOCATABLE                 :: DATAARRAY_I4P(:)  !< DATAARRAY BUFFER OF I4P.
+  INTEGER(I2P), ALLOCATABLE                 :: DATAARRAY_I2P(:)  !< DATAARRAY BUFFER OF I2P.
+  INTEGER(I1P), ALLOCATABLE                 :: DATAARRAY_I1P(:)  !< DATAARRAY BUFFER OF I1P.
+
+  CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"')
+  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_'
+  ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  DO
+    CALL READ_DATAARRAY_FROM_SCRATCH
+    IF (SELF%ERROR==0) CALL W_DATA_ON_XML
+    IF (IS_IOSTAT_END(SELF%ERROR)) EXIT
+  ENDDO
+  CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC
+  CALL SELF%WRITE_END_TAG(NAME='AppendedData')
+  CONTAINS
+    SUBROUTINE READ_DATAARRAY_FROM_SCRATCH
+    !< READ THE CURRENT DATAARAY FROM SCRATCH FILE.
+
+    READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM
+    SELECT CASE(DATAARRAY_TYPE)
+    CASE('R8')
+      IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P
+    CASE('R4')
+      IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P
+    CASE('I8')
+      IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P
+    CASE('I4')
+      IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P
+    CASE('I2')
+      IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P
+    CASE('I1')
+      IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P
+    CASE DEFAULT
+      SELF%ERROR = 1
+      WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE
+      WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE))
+      WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM))
+    ENDSELECT
+    10 RETURN
+    ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH
+
+    SUBROUTINE W_DATA_ON_XML
+    !< WRITE THE CURRENT DATAARAY ON XML FILE.
+    CHARACTER(LEN=:), ALLOCATABLE  :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC.
+
+    IF (SELF%ENCODING=='raw') THEN
+      SELECT CASE(DATAARRAY_TYPE)
+      CASE('R8')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P
+        DEALLOCATE(DATAARRAY_R8P)
+      CASE('R4')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P
+        DEALLOCATE(DATAARRAY_R4P)
+      CASE('I8')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P
+        DEALLOCATE(DATAARRAY_I8P)
+      CASE('I4')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P
+        DEALLOCATE(DATAARRAY_I4P)
+      CASE('I2')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P
+        DEALLOCATE(DATAARRAY_I2P)
+      CASE('I1')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P
+        DEALLOCATE(DATAARRAY_I1P)
+      ENDSELECT
+    ELSE
+      SELECT CASE(DATAARRAY_TYPE)
+      CASE('R8')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('R4')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I8')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I4')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I2')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I1')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      ENDSELECT
+    ENDIF
+    ENDSUBROUTINE W_DATA_ON_XML
+  ENDSUBROUTINE W_DATA_APPENDED
+
+  ! WRITE_ON_SCRATCH_DATAARRAY METHODS
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  CLASS(*),                   INTENT(IN)    :: X(1:)  !< DATA VARIABLE.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: NN     !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)
+  SELECT TYPE(X)
+  TYPE IS(REAL(R8P))
+    N_BYTE = NN*BYR8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(REAL(R4P))
+    N_BYTE = NN*BYR4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I8P))
+    N_BYTE = NN*BYI8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I4P))
+    N_BYTE = NN*BYI4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I2P))
+    N_BYTE = NN*BYI2P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I1P))
+    N_BYTE = NN*BYI1P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  ENDSELECT
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2(SELF, X) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 2.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  CLASS(*),                   INTENT(IN)    :: X(1:,1:) !< DATA VARIABLE.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: NN       !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
+  SELECT TYPE(X)
+  TYPE IS(REAL(R8P))
+    N_BYTE = NN*BYR8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(REAL(R4P))
+    N_BYTE = NN*BYR4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I8P))
+    N_BYTE = NN*BYI8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I4P))
+    N_BYTE = NN*BYI4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I2P))
+    N_BYTE = NN*BYI2P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I1P))
+    N_BYTE = NN*BYI1P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  ENDSELECT
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3(SELF, X) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 3.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  CLASS(*),                   INTENT(IN)    :: X(1:,1:,1:) !< DATA VARIABLE.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: NN          !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
+  SELECT TYPE(X)
+  TYPE IS(REAL(R8P))
+    N_BYTE = NN*BYR8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(REAL(R4P))
+    N_BYTE = NN*BYR4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I8P))
+    N_BYTE = NN*BYI8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I4P))
+    N_BYTE = NN*BYI4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I2P))
+    N_BYTE = NN*BYI2P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I1P))
+    N_BYTE = NN*BYI1P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  ENDSELECT
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4(SELF, X) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 4.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF           !< WRITER.
+  CLASS(*),                   INTENT(IN)    :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+  INTEGER(I4P)                              :: N_BYTE         !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: NN             !< NUMBER OF ELEMENTS.
+
+  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
+  SELECT TYPE(X)
+  TYPE IS(REAL(R8P))
+    N_BYTE = NN*BYR8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(REAL(R4P))
+    N_BYTE = NN*BYR4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I8P))
+    N_BYTE = NN*BYI8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I4P))
+    N_BYTE = NN*BYI4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I2P))
+    N_BYTE = NN*BYI2P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I1P))
+    N_BYTE = NN*BYI1P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  ENDSELECT
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P
+  
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1       !< COUNTER.
+  INTEGER(I4P)                              :: N2       !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
+                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), &
+                                                  X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P
+
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N1          !< COUNTER.
+  INTEGER(I4P)                              :: N2          !< COUNTER.
+  INTEGER(I4P)                              :: N3          !< COUNTER.
+
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
+                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P
+ENDMODULE VTKF_FILE_XML_WRITER_APPENDED
+
+
+
+
+!< VTK FILE XML WRITER, BINARY LOCAL.
+MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL
+!< VTK FILE XML WRITER, BINARY LOCAL.
+!<
+!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION).
+!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE
+!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER)
+!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL
+!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM.
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_DATAARRAY_ENCODER
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_BINARY_LOCAL
+
+TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL
+   !< VTK FILE XML WRITER, BINARY LOCAL.
+   CONTAINS
+      ! DEFERRED METHODS
+      PROCEDURE, PASS(SELF) :: INITIALIZE                 !< INITIALIZE WRITER.
+      PROCEDURE, PASS(SELF) :: FINALIZE                   !< FINALIZE WRITER.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
+ENDTYPE XML_WRITER_BINARY_LOCAL
+CONTAINS
+   FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
+                       IS_VOLATILE, MESH_KIND) RESULT(ERROR)
+   !< INITIALIZE WRITER.
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: FORMAT        !< FILE FORMAT: BINARY.
+   CHARACTER(*),                   INTENT(IN)           :: FILENAME      !< FILE NAME.
+   CHARACTER(*),                   INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+   CHARACTER(*),                   INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+
+   SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE
+   SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
+   SELF%FORMAT_CH = FORMAT
+   SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER()
+   CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME)
+   CALL SELF%WRITE_HEADER_TAG
+   CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
+   ERROR = SELF%ERROR
+   ENDFUNCTION INITIALIZE
+
+   FUNCTION FINALIZE(SELF) RESULT(ERROR)
+   !< FINALIZE WRITER.
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                                  :: ERROR !< ERROR STATUS.
+
+   CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS())
+   CALL SELF%WRITE_END_TAG(NAME='VTKFile')
+   CALL SELF%CLOSE_XML_FILE
+   ERROR = SELF%ERROR
+   ENDFUNCTION FINALIZE
+
+   ! W_DATA METHODS
+   FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_R8P
+
+   FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_R4P
+
+   FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_I8P
+
+   FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_I4P
+
+   FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_I2P
+
+   FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK1_I1P
+
+   FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_R8P
+
+   FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_R4P
+
+   FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_I8P
+
+   FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_I4P
+
+   FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_I2P
+
+   FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK2_I1P
+
+   FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_R8P
+
+   FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_R4P
+
+   FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_I8P
+
+   FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_I4P
+
+   FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_I2P
+
+   FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK3_I1P
+
+   FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_R8P
+
+   FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_R4P
+
+   FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_I8P
+
+   FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_I4P
+
+   FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_I2P
+
+   FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = SIZE(X, DIM=1)
+   IF (PRESENT(ONE_COMPONENT)) THEN
+     IF (ONE_COMPONENT) N_COMPONENTS = 1
+   ENDIF
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA1_RANK4_I1P
+
+   FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_R8P
+
+   FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_R4P
+
+   FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_I8P
+
+   FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_I4P
+
+   FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_I2P
+
+   FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK1_I1P
+
+   FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_R8P
+
+   FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_R4P
+
+   FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_I8P
+
+   FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_I4P
+
+   FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_I2P
+
+   FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA3_RANK3_I1P
+   
+   FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_R8P
+
+   FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_R4P
+
+   FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_I8P
+
+   FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_I4P
+
+   FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_I2P
+
+   FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK1_I1P
+
+   FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R8P),                      INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float64'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_R8P
+
+   FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   REAL(R4P),                      INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Float32'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_R4P
+
+   FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I8P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int64'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_I8P
+
+   FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I4P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int32'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_I4P
+
+   FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I2P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int16'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_I2P
+
+   FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+   INTEGER(I1P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
+   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+
+   DATA_TYPE = 'Int8'
+   N_COMPONENTS = 6
+   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
+                                 IS_TUPLES=IS_TUPLES)
+   ERROR = SELF%ERROR
+   ENDFUNCTION W_DATA6_RANK3_I1P
+
+   SUBROUTINE W_DATA_APPENDED(SELF)
+   !< DO NOTHING, BINARY LOCAL IS NOT APPENDED.
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
+   ENDSUBROUTINE W_DATA_APPENDED
+ENDMODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL
+
+
+
+
+
+!< VTM FILE CLASS.
+MODULE VTK_FORTRAN_VTM_FILE
+!< VTM FILE CLASS.
+USE BEFOR64
+USE PENF
+USE STRINGIFOR
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+USE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: VTM_FILE
+
+TYPE :: VTM_FILE
+   !< VTM FILE CLASS.
+   CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER      !< XML WRITER.
+   INTEGER(I4P), ALLOCATABLE                       :: SCRATCH_UNIT(:) !< SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS.
+   CONTAINS
+      ! PUBLIC METHODS
+      PROCEDURE, PASS(SELF) :: INITIALIZE          !< INITIALIZE FILE.
+      PROCEDURE, PASS(SELF) :: FINALIZE            !< FINALIZE FILE.
+      GENERIC               :: WRITE_BLOCK =>      &
+                               WRITE_BLOCK_ARRAY,  &
+                               WRITE_BLOCK_STRING, &
+                               WRITE_BLOCK_SCRATCH !< WRITE ONE BLOCK DATASET.
+      ! PRIVATE METHODS
+      PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_ARRAY  !< WRITE ONE BLOCK DATASET (ARRAY INPUT).
+      PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_STRING !< WRITE ONE BLOCK DATASET (STRING INPUT).
+      ! SCRATCH FILES METHODS``
+      PROCEDURE, PASS(SELF), PRIVATE :: PARSE_SCRATCH_FILES !< PARSE SCRATCH FILES.
+      PROCEDURE, PASS(SELF), PRIVATE :: WRITE_BLOCK_SCRATCH !< WRITE ONE BLOCK DATASET ON SCRATCH FILES.
+ENDTYPE VTM_FILE
+CONTAINS
+  ! PUBLIC METHODS
+  FUNCTION INITIALIZE(SELF, FILENAME, SCRATCH_UNITS_NUMBER) RESULT(ERROR)
+  !< INITIALIZE FILE (WRITER).
+  CLASS(VTM_FILE), INTENT(INOUT)        :: SELF                  !< VTM FILE.
+  CHARACTER(*),    INTENT(IN)           :: FILENAME              !< FILE NAME OF OUTPUT VTM FILE.
+  INTEGER(I4P),    INTENT(IN), OPTIONAL :: SCRATCH_UNITS_NUMBER  !< NUMBER OF SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS.
+  INTEGER(I4P)                          :: SCRATCH_UNITS_NUMBER_ !< NUMBER OF SCRATCH UNITS FOR VERY LARGE LIST OF NAMED BLOCKS.
+  INTEGER(I4P)                          :: ERROR                 !< ERROR STATUS.
+
+  IF (.NOT.IS_INITIALIZED) CALL PENF_INIT
+  IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT
+  SCRATCH_UNITS_NUMBER_ = 0_I4P ; IF (PRESENT(SCRATCH_UNITS_NUMBER)) SCRATCH_UNITS_NUMBER_ = SCRATCH_UNITS_NUMBER
+  ERROR = SELF%FINALIZE()
+  IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER)
+  ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER)
+  ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT='ascii', FILENAME=FILENAME, MESH_TOPOLOGY='VTKMULTIBLOCKDATASET')
+  IF (SCRATCH_UNITS_NUMBER_>0_I4P) ALLOCATE(SELF%SCRATCH_UNIT(SCRATCH_UNITS_NUMBER_))
+  ENDFUNCTION INITIALIZE
+
+  FUNCTION FINALIZE(SELF) RESULT(ERROR)
+  !< FINALIZE FILE (WRITER).
+  CLASS(VTM_FILE), INTENT(INOUT) :: SELF  !< VTM FILE.
+  INTEGER(I4P)                   :: ERROR !< ERROR STATUS.
+
+  ERROR = 1
+  IF (ALLOCATED(SELF%SCRATCH_UNIT)) THEN
+     ERROR = SELF%PARSE_SCRATCH_FILES()
+     DEALLOCATE(SELF%SCRATCH_UNIT)
+  ENDIF
+  IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE()
+  ENDFUNCTION FINALIZE
+
+  ! PRIVATE METHODS
+  FUNCTION WRITE_BLOCK_ARRAY(SELF, FILENAMES, NAMES, NAME) RESULT(ERROR)
+  !< WRITE ONE BLOCK DATASET (ARRAY INPUT).
+  !<
+  !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS
+  !<```FORTRAN
+  !< ERROR = VTM%WRITE_BLOCK(FILENAMES=['FILE_1.VTS', 'FILE_2.VTS', 'FILE_3.VTU'], NAME='MY_BLOCK')
+  !<```
+  !<
+  !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME
+  !<```FORTRAN
+  !< ERROR = VTM%WRITE_BLOCK(FILENAMES=['FILE_1.VTS', 'FILE_2.VTS', 'FILE_3.VTU'], &
+  !<                         NAMES=['BLOCK-BAR', 'BLOCK-FOO', 'BLOCK-BAZ'], NAME='MY_BLOCK')
+  !<```
+  CLASS(VTM_FILE), INTENT(INOUT)        :: SELF          !< VTM FILE.
+  CHARACTER(*),    INTENT(IN)           :: FILENAMES(1:) !< FILE NAMES OF VTK FILES GROUPED INTO CURRENT BLOCK.
+  CHARACTER(*),    INTENT(IN), OPTIONAL :: NAMES(1:)     !< AUXILIARY NAMES ATTRIBUTED TO EACH FILES.
+  CHARACTER(*),    INTENT(IN), OPTIONAL :: NAME          !< BLOCK NAME
+  INTEGER(I4P)                          :: ERROR         !< ERROR STATUS.
+
+  ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME)
+  ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES)
+  ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK()
+  ENDFUNCTION WRITE_BLOCK_ARRAY
+
+   FUNCTION WRITE_BLOCK_STRING(SELF, ACTION, FILENAMES, NAMES, NAME) RESULT(ERROR)
+   !< WRITE ONE BLOCK DATASET (STRING INPUT).
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU', NAME='MY_BLOCK')
+   !<```
+   !<
+   !<#### EXAMPLE OF USAGE: 3 FILES BLOCKS WITH CUSTOM NAME
+   !<```FORTRAN
+   !< ERROR = VTM%WRITE_BLOCK(FILENAMES='FILE_1.VTS FILE_2.VTS FILE_3.VTU', NAMES='BLOCK-BAR BLOCK-FOO BLOCK-BAZ', NAME='MY_BLOCK')
+   !<```
+   CLASS(VTM_FILE), INTENT(INOUT)        :: SELF      !< VTM FILE.
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: ACTION    !< ACTION: [OPEN, CLOSE, WRITE].
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: FILENAMES !< FILE NAMES OF VTK FILES GROUPED INTO CURRENT BLOCK.
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: NAMES     !< AUXILIARY NAMES ATTRIBUTED TO EACH FILES.
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: NAME      !< BLOCK NAME
+   INTEGER(I4P)                          :: ERROR     !< ERROR STATUS.
+   TYPE(STRING)                          :: ACTION_   !< ACTION STRING.
+
+   IF (PRESENT(ACTION)) THEN
+      ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER()
+      SELECT CASE(ACTION_%CHARS())
+      CASE('OPEN')
+         ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME)
+      CASE('CLOSE')
+         ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK()
+      CASE('WRITE')
+         IF (PRESENT(FILENAMES)) ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES)
+      ENDSELECT
+   ELSE
+      ERROR = SELF%XML_WRITER%WRITE_PARALLEL_OPEN_BLOCK(NAME=NAME)
+      ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILENAMES=FILENAMES, NAMES=NAMES)
+      ERROR = SELF%XML_WRITER%WRITE_PARALLEL_CLOSE_BLOCK()
+   ENDIF
+   ENDFUNCTION WRITE_BLOCK_STRING
+
+   ! SCRATCH FILES METHODS
+   FUNCTION PARSE_SCRATCH_FILES(SELF) RESULT(ERROR)
+   !< PARSE SCRATCH FILES.
+   CLASS(VTM_FILE), INTENT(INOUT) :: SELF     !< VTM FILE.
+   INTEGER(I4P)                   :: ERROR    !< ERROR STATUS.
+   CHARACTER(9999)                :: FILENAME !< FILE NAME OF VTK FILE GROUPED INTO CURRENT BLOCK.
+   CHARACTER(9999)                :: NAME     !< BLOCK NAME
+   INTEGER(I4P)                   :: S, F     !< COUNTER.
+
+   IF (ALLOCATED(SELF%SCRATCH_UNIT)) THEN
+      DO S=1, SIZE(SELF%SCRATCH_UNIT, DIM=1)
+         ! REWIND SCRATCH FILE
+         REWIND(SELF%SCRATCH_UNIT(S))
+         ! WRITE GROUP NAME
+         F = 0_I4P
+         READ(SELF%SCRATCH_UNIT(S), IOSTAT=ERROR, FMT=*) NAME
+         ERROR = SELF%WRITE_BLOCK(ACTION='OPEN', NAME=TRIM(ADJUSTL(NAME)))
+         ! WRITE GROUP FILENAMES
+         PARSE_FILE_LOOP : DO
+            READ(SELF%SCRATCH_UNIT(S), IOSTAT=ERROR, FMT=*) FILENAME
+            IF (IS_IOSTAT_END(ERROR)) EXIT PARSE_FILE_LOOP
+            ERROR = SELF%XML_WRITER%WRITE_PARALLEL_BLOCK_FILES(FILE_INDEX=F,                     &
+                                                               FILENAME=TRIM(ADJUSTL(FILENAME)), &
+                                                               NAME=TRIM(ADJUSTL(FILENAME)))
+            F = F + 1_I4P
+         ENDDO PARSE_FILE_LOOP
+         ! CLOSE GROUP
+         ERROR = SELF%WRITE_BLOCK(ACTION='CLOSE')
+         ! CLOSE SCRATCH FILE
+         CLOSE(SELF%SCRATCH_UNIT(S))
+      ENDDO
+   ENDIF
+   ENDFUNCTION PARSE_SCRATCH_FILES
+
+   FUNCTION WRITE_BLOCK_SCRATCH(SELF, SCRATCH, ACTION, FILENAME, NAME) RESULT(ERROR)
+   !< WRITE ONE BLOCK DATASET ON SCRATCH FILES.
+   CLASS(VTM_FILE), INTENT(INOUT)        :: SELF     !< VTM FILE.
+   INTEGER(I4P),    INTENT(IN)           :: SCRATCH  !< SCRATCH UNIT.
+   CHARACTER(*),    INTENT(IN)           :: ACTION   !< ACTION: [OPEN, WRITE].
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: FILENAME !< FILE NAME OF VTK FILE GROUPED INTO CURRENT BLOCK.
+   CHARACTER(*),    INTENT(IN), OPTIONAL :: NAME     !< BLOCK NAME
+   INTEGER(I4P)                          :: ERROR    !< ERROR STATUS.
+   TYPE(STRING)                          :: ACTION_  !< ACTION STRING.
+   TYPE(STRING)                          :: NAME_    !< BLOCK NAME, LOCAL VARIABLE
+
+   ACTION_ = TRIM(ADJUSTL(ACTION)) ; ACTION_ = ACTION_%UPPER()
+   SELECT CASE(ACTION_%CHARS())
+   CASE('OPEN')
+     OPEN(NEWUNIT=SELF%SCRATCH_UNIT(SCRATCH), &
+          FORM='FORMATTED',                   &
+          ACTION='READWRITE',                 &
+          STATUS='SCRATCH',                   &
+          IOSTAT=ERROR)
+      NAME_ = '' ; IF (PRESENT(NAME)) NAME_ = TRIM(ADJUSTL(NAME))
+      WRITE(SELF%SCRATCH_UNIT(SCRATCH), IOSTAT=ERROR, FMT='(A)') NAME_%CHARS()
+   CASE('WRITE')
+      IF (PRESENT(FILENAME)) WRITE(SELF%SCRATCH_UNIT(SCRATCH), IOSTAT=ERROR, FMT='(A)') TRIM(FILENAME)
+   ENDSELECT
+   ENDFUNCTION WRITE_BLOCK_SCRATCH
+ENDMODULE VTK_FORTRAN_VTM_FILE
+
+
+
+
+!< VTK FILE CLASS.
+MODULE VTK_FORTRAN_VTK_FILE
+!< VTK FILE CLASS.
+USE BEFOR64
+USE PENF
+USE STRINGIFOR
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+USE VTKF_FILE_XML_WRITER_APPENDED
+USE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+USE VTKF_FILE_XML_WRITER_BINARY_LOCAL
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: VTK_FILE
+
+TYPE :: VTK_FILE
+  !< VTK FILE CLASS.
+  PRIVATE
+  CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER !< XML WRITER.
+  CONTAINS
+    PROCEDURE, PASS(SELF) :: GET_XML_VOLATILE !< RETURN THE EVENTUAL XML VOLATILE STRING FILE.
+    PROCEDURE, PASS(SELF) :: INITIALIZE       !< INITIALIZE FILE.
+    PROCEDURE, PASS(SELF) :: FINALIZE         !< FINALIZE FILE.
+    PROCEDURE, PASS(SELF) :: FREE             !< FREE ALLOCATED MEMORY.
+ENDTYPE VTK_FILE
+CONTAINS
+   PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR)
+   !< RETURN THE EVENTUAL XML VOLATILE STRING FILE.
+   CLASS(VTK_FILE),  INTENT(IN)               :: SELF         !< VTK FILE.
+   CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE.
+   INTEGER(I4P),     INTENT(OUT), OPTIONAL    :: ERROR !< ERROR STATUS.
+
+   CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE, ERROR=ERROR)
+   ENDSUBROUTINE GET_XML_VOLATILE
+
+   FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR)
+   !< INITIALIZE FILE (WRITER).
+   !<
+   !< @NOTE THIS FUNCTION MUST BE THE FIRST TO BE CALLED.
+   !<
+   !<### SUPPORTED OUTPUT FORMATS ARE (THE PASSED SPECIFIER VALUE IS CASE INSENSITIVE):
+   !<
+   !<- ASCII: DATA ARE SAVED IN ASCII FORMAT;
+   !<- BINARY: DATA ARE SAVED IN BASE64 ENCODED FORMAT;
+   !<- RAW: DATA ARE SAVED IN RAW-BINARY FORMAT IN THE APPENDED TAG OF THE XML FILE;
+   !<- BINARY-APPENDED: DATA ARE SAVED IN BASE64 ENCODED FORMAT IN THE APPENDED TAG OF THE XML FILE.
+   !<
+   !<### SUPPORTED TOPOLOGIES ARE:
+   !<
+   !<- RECTILINEARGRID;
+   !<- STRUCTUREDGRID;
+   !<- UNSTRUCTUREDGRID.
+   !<
+   !<### EXAMPLE OF USAGE
+   !<
+   !<```FORTRAN
+   !< TYPE(VTK_FILE) :: VTK
+   !< INTEGER(I4P)   :: NX1, NX2, NY1, NY2, NZ1, NZ2
+   !< ...
+   !< ERROR = VTK%INITIALIZE('binary','XML_RECT_BINARY.VTR','RectilinearGrid',NX1=NX1,NX2=NX2,NY1=NY1,NY2=NY2,NZ1=NZ1,NZ2=NZ2)
+   !< ...
+   !<```
+   !< @NOTE THE FILE EXTENSION IS NECESSARY IN THE FILE NAME. THE XML STANDARD HAS DIFFERENT EXTENSIONS FOR EACH
+   !< DIFFERENT TOPOLOGIES (E.G. *VTR* FOR RECTILINEAR TOPOLOGY). SEE THE VTK-STANDARD FILE FOR MORE INFORMATION.
+   CLASS(VTK_FILE), INTENT(INOUT)        :: SELF          !< VTK FILE.
+   CHARACTER(*),    INTENT(IN)           :: FORMAT        !< FILE FORMAT: ASCII, BINARY, RAW OR BINARY-APPENDED.
+   CHARACTER(*),    INTENT(IN)           :: FILENAME      !< FILE NAME.
+   CHARACTER(*),    INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+   LOGICAL,         INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),    INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+   INTEGER(I4P)                          :: ERROR         !< ERROR STATUS.
+   TYPE(STRING)                          :: FFORMAT       !< FILE FORMAT.
+
+   IF (.NOT.IS_INITIALIZED) CALL PENF_INIT
+   IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT
+   FFORMAT = TRIM(ADJUSTL(FORMAT))
+   FFORMAT = FFORMAT%UPPER()
+   IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER)
+   SELECT CASE(FFORMAT%CHARS())
+   CASE('ascii')
+      ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER)
+   CASE('binary-appended', 'raw')
+      ALLOCATE(XML_WRITER_APPENDED :: SELF%XML_WRITER)
+   CASE('binary')
+      ALLOCATE(XML_WRITER_BINARY_LOCAL :: SELF%XML_WRITER)
+   CASE DEFAULT
+      ERROR = 1
+   ENDSELECT
+   ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT=FORMAT, FILENAME=FILENAME, MESH_TOPOLOGY=MESH_TOPOLOGY, &
+                                      IS_VOLATILE=IS_VOLATILE,                                       &
+                                      NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2)
+   ENDFUNCTION INITIALIZE
+
+   FUNCTION FINALIZE(SELF) RESULT(ERROR)
+   !< FINALIZE FILE (WRITER).
+   CLASS(VTK_FILE), INTENT(INOUT)  :: SELF  !< VTK FILE.
+   INTEGER(I4P)                    :: ERROR !< ERROR STATUS.
+   CHARACTER(LEN=:),           ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE.
+
+   ERROR = 1
+   IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE()
+   ENDFUNCTION FINALIZE
+
+   ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
+   !< FREE ALLOCATED MEMORY.
+   CLASS(VTK_FILE), INTENT(INOUT)         :: SELF  !< VTK FILE.
+   INTEGER(I4P),    INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS.
+
+   IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE(ERROR=ERROR)
+   ENDSUBROUTINE FREE
+ENDMODULE VTK_FORTRAN_VTK_FILE
+
+
+
+!< PARALLEL (PARTIONED) VTK FILE CLASS.
+MODULE VTK_FORTRAN_PVTK_FILE
+!< PARALLEL (PARTIONED) VTK FILE CLASS.
+USE BEFOR64
+USE PENF
+USE VTKF_FILE_XML_WRITER_ABSTRACT
+USE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: PVTK_FILE
+
+TYPE :: PVTK_FILE
+  !< VTK PARALLEL (PARTIONED) FILE CLASS.
+  PRIVATE
+  CLASS(XML_WRITER_ABSTRACT), ALLOCATABLE, PUBLIC :: XML_WRITER !< XML WRITER.
+  CONTAINS
+    PROCEDURE, PASS(SELF) :: INITIALIZE !< INITIALIZE FILE.
+    PROCEDURE, PASS(SELF) :: FINALIZE   !< FINALIZE FILE.
+ENDTYPE PVTK_FILE
+CONTAINS
+  FUNCTION INITIALIZE(SELF, FILENAME, MESH_TOPOLOGY, MESH_KIND, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR)
+  !< INITIALIZE FILE (WRITER).
+  !<
+  !< @NOTE THIS FUNCTION MUST BE THE FIRST TO BE CALLED.
+  !<
+  !<### SUPPORTED TOPOLOGIES ARE:
+  !<
+  !<- PRECTILINEARGRID;
+  !<- PSTRUCTUREDGRID;
+  !<- PUNSTRUCTUREDGRID.
+  !<
+  !<### EXAMPLE OF USAGE
+  !<
+  !<```FORTRAN
+  !< TYPE(PVTK_FILE) :: PVTK
+  !< INTEGER(I4P)    :: NX1, NX2, NY1, NY2, NZ1, NZ2
+  !< ...
+  !< ERROR = PVTK%INITIALIZE('XML_RECT_BINARY.PVTR','PRectilinearGrid',NX1=NX1,NX2=NX2,NY1=NY1,NY2=NY2,NZ1=NZ1,NZ2=NZ2)
+  !< ...
+  !<```
+  !< @NOTE THE FILE EXTENSION IS NECESSARY IN THE FILE NAME. THE XML STANDARD HAS DIFFERENT EXTENSIONS FOR EACH
+  !< DIFFERENT TOPOLOGIES (E.G. *PVTR* FOR RECTILINEAR TOPOLOGY). SEE THE VTK-STANDARD FILE FOR MORE INFORMATION.
+  CLASS(PVTK_FILE), INTENT(INOUT)         :: SELF          !< VTK FILE.
+  CHARACTER(*),     INTENT(IN)            :: FILENAME      !< FILE NAME.
+  CHARACTER(*),     INTENT(IN)            :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+  CHARACTER(*),     INTENT(IN)            :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+  INTEGER(I4P),     INTENT(IN),  OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+  INTEGER(I4P)                            :: ERROR         !< ERROR STATUS.
+
+  IF (.NOT.IS_INITIALIZED) CALL PENF_INIT
+  IF (.NOT.IS_B64_INITIALIZED) CALL B64_INIT
+  IF (ALLOCATED(SELF%XML_WRITER)) DEALLOCATE(SELF%XML_WRITER)
+  ALLOCATE(XML_WRITER_ASCII_LOCAL :: SELF%XML_WRITER)
+  ERROR = SELF%XML_WRITER%INITIALIZE(FORMAT='ascii', FILENAME=FILENAME, MESH_TOPOLOGY=MESH_TOPOLOGY, &
+                                     NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
+  ENDFUNCTION INITIALIZE
+
+  FUNCTION FINALIZE(SELF) RESULT(ERROR)
+  !< FINALIZE FILE (WRITER).
+  CLASS(PVTK_FILE), INTENT(INOUT) :: SELF  !< VTK FILE.
+  INTEGER(I4P)                    :: ERROR !< ERROR STATUS.
+
+  ERROR = 1
+  IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE()
+  ENDFUNCTION FINALIZE
+ENDMODULE VTK_FORTRAN_PVTK_FILE
+
+
+
+
+!< VTK_FORTRAN, PURE FORTRAN (2003+) LIBRARY TO PARSE AND EMITT VTK FILES.
+MODULE VTK_FORTRAN
+!< VTK_FORTRAN, PURE FORTRAN (2003+) LIBRARY TO PARSE AND EMITT VTK FILES.
+USE PENF
+USE VTK_FORTRAN_PVTK_FILE, ONLY : PVTK_FILE
+USE VTK_FORTRAN_VTK_FILE, ONLY : VTK_FILE
+USE VTK_FORTRAN_VTM_FILE, ONLY : VTM_FILE
+
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: PVTK_FILE
+PUBLIC :: VTK_FILE
+PUBLIC :: VTM_FILE
+PUBLIC :: WRITE_XML_VOLATILE
+
+CONTAINS
+   FUNCTION WRITE_XML_VOLATILE(XML_VOLATILE, FILENAME) RESULT(ERROR)
+   !< WRITE THE VOLATILE FILE INTO A REAL FILE.
+   !< THIS IS WHAT A MASTER PROCESS SHOULD DO INTO A PARALLEL SCENARIO WHERE IT BEING THE ONLY PROCESS ALLOWED TO ACCESS TO
+   !< FILESYSTEM: SLAVE PROCESSES CREATE XML VOLATILE FILE ECONDED INTO A CHARACTERS STRING AND MASTER PROCESS COLLECTS AND WRITES
+   !< THEM BY MEANS OF `WRITE_XML_VOLATILE`.
+   CHARACTER(*), INTENT(IN) :: XML_VOLATILE !< XML VOLATILE FILE.
+   CHARACTER(*), INTENT(IN) :: FILENAME     !< XML FILE NAME.
+   INTEGER(I4P)             :: ERROR        !< STATUS ERROR.
+   INTEGER(I4P)             :: XML_UNIT     !< XML FILE UNIT.
+
+   OPEN(NEWUNIT=XML_UNIT,             &
+        FILE=TRIM(ADJUSTL(FILENAME)), &
+        FORM='UNFORMATTED',           &
+        ACCESS='STREAM',              &
+        ACTION='WRITE',               &
+        STATUS='REPLACE',             &
+        IOSTAT=ERROR)
+   WRITE(UNIT=XML_UNIT, IOSTAT=ERROR) XML_VOLATILE
+   ENDFUNCTION WRITE_XML_VOLATILE
+ENDMODULE VTK_FORTRAN
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+!> \brief Routines for handling vtk output
+
+MODULE VTK_FDS_INTERFACE
+
+USE MESH_VARIABLES
+USE GLOBAL_CONSTANTS
+USE MESH_POINTERS
+USE OUTPUT_DATA
+USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
+
+IMPLICIT NONE (TYPE,EXTERNAL)
+PRIVATE
+
+PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,&
+       WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,&
+       DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
+
+CONTAINS
+
+SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+TYPE (SLICE_TYPE), POINTER :: SL
+INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
+REAL(FB) :: STIME
+REAL(EB) :: TT
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu'
+
+! First part of header before quantities
+OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED')
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
+   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
+
+! Add PointData arrays
+NQT = MESHES(1)%N_SLCF
+QUANTITY_LOOP2: DO IQ=1,NQT
+   SL => SLICE(IQ)
+   I1  = SL%I1
+   I2  = SL%I2
+   J1  = SL%J1
+   J2  = SL%J2
+   K1  = SL%K1
+   K2  = SL%K2
+   IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format='
+   IF (VTK_BINARY) THEN
+      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+   ELSE
+      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+   ENDIF
+ENDDO QUANTITY_LOOP2
+
+! Close PointData
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
+
+! Add Point arrays
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
+IF (VTK_BINARY) THEN
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
+ELSE
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
+ENDIF
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
+
+! Add CellData
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
+
+! Write pieces
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu'
+   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
+ENDDO
+
+! Finalize file
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
+WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
+CLOSE(LU_SL3D_VTK(NMESHES+1))
+END SUBROUTINE WRITE_VTK_SLICE_WRAPPER
+
+
+
+SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+TYPE (SLICE_TYPE), POINTER :: SL
+INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
+REAL(FB) :: STIME
+REAL(EB) :: TT
+TYPE(PVTK_FILE)          :: A_PVTK_FILE       !< A parallel (partioned) VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu'
+VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_SL3D_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',&
+                                   MESH_KIND='Float32')
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN')
+! Add PointData arrays
+NQT = MESHES(1)%N_SLCF
+QUANTITY_LOOP2: DO IQ=1,NQT
+   SL => SLICE(IQ)
+   I1  = SL%I1
+   I2  = SL%I2
+   J1  = SL%J1
+   J2  = SL%J2
+   K1  = SL%K1
+   K2  = SL%K2
+   IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(SL%SMOKEVIEW_LABEL(1:30)), &
+                                                           DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1)
+ENDDO QUANTITY_LOOP2
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE')
+
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu'
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE)
+ENDDO
+
+VTK_ERROR = A_PVTK_FILE%FINALIZE()
+END SUBROUTINE WRITE_VTK_SL3D_WRAPPER
+
+
+
+
+
+
+
+
+
+
+
+
+
+SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+INTEGER :: I,ITM,ITM1,N
+REAL(FB) :: STIME
+REAL(EB) :: TT
+TYPE(SMOKE3D_TYPE), POINTER :: S3
+TYPE(PVTK_FILE)          :: A_PVTK_FILE       !< A parallel (partioned) VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_SMOKE3D_VTK(NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_','SM3D','_',ITM,ITM1,'.pvtu'
+VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_SMOKE3D_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',&
+                                   MESH_KIND='Float32')
+! Add PointData arrays
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN')
+DATA_FILE_LOOP2: DO N=1,N_SMOKE3D
+   S3 => SMOKE3D_FILE(N)
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(S3%SMOKEVIEW_LABEL(1:30)), &
+                                                           DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1)
+ENDDO DATA_FILE_LOOP2
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE')
+
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SM3D_',I,'_',ITM,ITM1,'.vtu'
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE)
+ENDDO
+
+VTK_ERROR = A_PVTK_FILE%FINALIZE()
+END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
+
+
+
+SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, &
+                                        NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+
+INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN
+INTEGER, INTENT(IN) :: NM
+
+NX = SIZE(MESHES(NM)%X)
+NY = SIZE(MESHES(NM)%Y)
+NZ = SIZE(MESHES(NM)%Z)
+
+NP = NX*NY*NZ
+NC = (NX-1)*(NY-1)*(NZ-1)
+
+! Fill point data
+ALLOCATE(X_PTS(NP))
+ALLOCATE(Y_PTS(NP))
+ALLOCATE(Z_PTS(NP))
+IFACT = 1
+DO K = 0, NZ-1
+   DO J = 0, NY-1
+      DO I = 0, NX-1
+         X_PTS(IFACT)=MESHES(NM)%X(I)
+         Y_PTS(IFACT)=MESHES(NM)%Y(J)
+         Z_PTS(IFACT)=MESHES(NM)%Z(K)
+         IFACT = IFACT + 1
+      ENDDO
+   ENDDO
+ENDDO
+
+! Fill cell data
+ALLOCATE(CONNECT(NC*8))
+DO I = 1, NX-1
+   IFACT = (I-1)
+   DO J = 1, NY-1
+      JFACT = (J-1)*(NX-1)
+      DO K = 1, NZ-1
+         KFACT = (K - 1)*(NY-1)*(NX-1)
+         CONNECT((IFACT+JFACT+KFACT)*8+1) = (K-1)*(NY*NX) + (J-1)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+2) = (K-1)*(NY*NX) + (J-1)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+3) = (K-1)*(NY*NX) + (J)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+4) = (K-1)*(NY*NX) + (J)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+5) = (K)*(NY*NX) + (J-1)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+6) = (K)*(NY*NX) + (J-1)*NX + I
+         CONNECT((IFACT+JFACT+KFACT)*8+7) = (K)*(NY*NX) + (J)*NX + I-1
+         CONNECT((IFACT+JFACT+KFACT)*8+8) = (K)*(NY*NX) + (J)*NX + I
+      ENDDO
+   ENDDO
+ENDDO
+
+ALLOCATE(OFFSETS(NC))
+ALLOCATE(VTKC_TYPE(NC))
+
+DO I=1,NC
+   OFFSETS(I) = (I)*8_IB32
+   VTKC_TYPE(I) = 11_IB8
+ENDDO
+         
+ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY
+         
+
+      
+SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+
+REAL(FB), DIMENSION(:), ALLOCATABLE :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), DIMENSION(:), ALLOCATABLE :: CONNECT, OFFSETS
+INTEGER(IB8), DIMENSION(:), ALLOCATABLE :: VTKC_TYPE
+DEALLOCATE(OFFSETS)
+DEALLOCATE(VTKC_TYPE)
+DEALLOCATE(CONNECT)
+DEALLOCATE(X_PTS)
+DEALLOCATE(Y_PTS)
+DEALLOCATE(Z_PTS)
+
+ENDSUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
+
+END MODULE VTK_FDS_INTERFACE
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 3445fd0ebd8346fba18be4802d30d17cbf3aeecb Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Fri, 5 Jan 2024 15:11:39 -0500
Subject: [PATCH 22/31] Add VTK output for BDNF

---
 Source/cons.f90 |   7 +-
 Source/dump.f90 | 495 ++++++++++++++++++++++----------
 Source/func.f90 |   1 +
 Source/vtkf.f90 | 742 ++++++------------------------------------------
 4 files changed, 429 insertions(+), 816 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 2169784f3d7..146726680db 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -549,7 +549,7 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, &
                                               FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF
-CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK
+CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK
 
 CHARACTER(9) :: FMT_R
 LOGICAL :: OUT_FILE_OPENED=.FALSE.
@@ -762,14 +762,15 @@ MODULE OUTPUT_CLOCKS
 INTEGER :: RAMP_SPEC_INDEX=0       !< Ramp index for species file time series
 INTEGER :: RAMP_SL3D_VTK_INDEX=0   !< Ramp index for vtk file time series
 INTEGER :: RAMP_SM3D_VTK_INDEX=0   !< Ramp index for vtk file time series
+INTEGER :: RAMP_BNDF_VTK_INDEX=0   !< Ramp index for boundary file time series
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,&
                                        ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,&
                                        SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,&
-                                       SL3D_VTK_CLOCK,SM3D_VTK_CLOCK
+                                       SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK
 INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,&
                                       HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,&
                                       RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,&
-                                      SL3D_VTK_COUNTER,SM3D_VTK_COUNTER
+                                      SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER
 REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB
 REAL(EB) :: MMS_TIMER=1.E10_EB
 REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,&
diff --git a/Source/dump.f90 b/Source/dump.f90
index 4ac629df9f6..2d4748899a8 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,7 +19,7 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
-USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,&
+USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
                 WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
@@ -157,8 +157,18 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
+! VTK Boundary data
+
+IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN
+   CALL DUMP_BNDF(T,DT,NM,1)
+   DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1)
+      BNDF_VTK_COUNTER(NM) = BNDF_VTK_COUNTER(NM) + 1
+      IF (BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))>=T) EXIT
+   ENDDO
+ENDIF
+
 IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN
-   CALL DUMP_BNDF(T,DT,NM)
+   CALL DUMP_BNDF(T,DT,NM,0)
    DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1)
       BNDF_COUNTER(NM) = BNDF_COUNTER(NM) + 1
       IF (BNDF_CLOCK(BNDF_COUNTER(NM))>=T) EXIT
@@ -395,6 +405,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(LU_SL3D_VTK(NMESHES+1))
 ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1))
 ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1))
+ALLOCATE(FN_BNDF_VTK(NMESHES+1))
 
 MESH_LOOP: DO NM=1,NMESHES
 
@@ -4280,11 +4291,13 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
 USE ISOSMOKE, ONLY: SMOKE3D_TO_FILE
 REAL(EB), INTENT(IN) :: T,DT
 INTEGER,  INTENT(IN) :: NM,IFRMT
-INTEGER  :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP
+INTEGER  :: I,J,K,N,IFACT,JFACT,KFACT,ITM,ITM1,NC,NP,I1=0,J1=0,K1=0,I2,J2,K2,NX,NY,NZ
 REAL(FB) :: DXX,STIME
 REAL(EB), POINTER, DIMENSION(:,:,:) :: FF
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
-INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
+!INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
+CHARACTER(C_CHAR) :: C, MOLD
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
@@ -4371,30 +4384,30 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
       ENDIF
       WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
       !WRITE(FN_SMOKE3D_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "./results/",TRIM(CHID),'_SM3D_',NM,'_',ITM,ITM1,'.vtu'
-      !WRITE(*,*) "ARRAY SIZES ", IBAR, JBAR, KBAR, IBP1, JBP1, KBP1
-      ALLOCATE(QQ_PACK(IBP1*JBP1*KBP1))
-      DO I = 0, IBAR
-         IFACT = I
-         DO J = 0, JBAR
-            JFACT = J*(IBAR)
-            DO K = 0, KBAR
-               KFACT = K*(JBAR)*(IBAR)
+      I2 = MESHES(NM)%IBAR
+      J2 = MESHES(NM)%JBAR
+      K2 = MESHES(NM)%KBAR
+      NX = I2 + 1 - I1
+      NY = J2 + 1 - J1
+      NZ = K2 + 1 - K1
+      ALLOCATE(QQ_PACK(NX*NY*NZ))
+      DO I = I1, I2
+         IFACT = (I-I1)
+         DO J = J1, J2
+            JFACT = (J-J1)*NX
+            DO K = K1, K2
+               KFACT = (K - K1)*NY*NX
                QQ_PACK(1+IFACT+JFACT+KFACT) = QQ(I,J,K,1)
             ENDDO
          ENDDO
       ENDDO
       IF (N .EQ. 1) THEN
-         !CALL INITIALIZE_VTK(LU_SMOKE3D_VTK(NM),FN_SMOKE3D_VTK(NM),'UnstructuredGrid')
-         !CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM),  &
-         !                                  NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
-         !CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
-         !
          IF (VTK_BINARY) THEN
             VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
          ELSE
             VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
          ENDIF ! do not change capitalization on mesh topology
-         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SMOKE3D_VTK(NM), &
+         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', &
                                            NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
@@ -4403,22 +4416,22 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
          CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
          
       ENDIF
-      ALLOCATE(QQ_PACK_INT(IBP1*JBP1*KBP1))
+      ALLOCATE(QQ_PACK_INT(NX*NY*NZ))
       IF (S3%DISPLAY_TYPE=='GAS') THEN
 
          FACTOR=-REAL(S3%MASS_EXTINCTION_COEFFICIENT,FB)*DXX
          DO I=1,NP
             VAL_FDS = MAX(0.0_FB,QQ_PACK(I))
-            VAL_SMV = 254*(1.0_FB-EXP(FACTOR*VAL_FDS))
-            QQ_PACK_INT(I) = NINT(VAL_SMV)
+            VAL_SMV = 127*(1.0_FB-EXP(FACTOR*VAL_FDS))
+            QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV)
          ENDDO
 
       ELSEIF (S3%DISPLAY_TYPE=='FIRE') THEN
 
          DO I=1,NP
             VAL_FDS = MIN(HRRPUV_MAX_SMV,MAX(0._FB,QQ_PACK(I)))
-            VAL_SMV = 254*(VAL_FDS/HRRPUV_MAX_SMV)
-            QQ_PACK_INT(I) = NINT(VAL_SMV)
+            VAL_SMV = 127*(VAL_FDS/HRRPUV_MAX_SMV)
+            QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV)
          ENDDO
 
       ELSEIF (S3%DISPLAY_TYPE=='TEMPERATURE') THEN
@@ -4426,13 +4439,13 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
          TEMP_MIN = REAL(TMPA-TMPM,FB)
          DO I=1,NP
             VAL_FDS = MIN(TEMP_MAX_SMV,MAX(TEMP_MIN,QQ_PACK(I)))
-            VAL_SMV = 254*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN))
-            QQ_PACK_INT(I) = NINT(VAL_SMV)
+            VAL_SMV = 127*((VAL_FDS-TEMP_MIN)/(TEMP_MAX_SMV-TEMP_MIN))
+            QQ_PACK_INT(I) = VAL_SMV !NINT(VAL_SMV)
          ENDDO
 
       ELSE
          DO I=1,NP
-            QQ_PACK_INT(I) = NINT(QQ_PACK(I))
+            QQ_PACK_INT(I) = QQ_PACK(I) !NINT(QQ_PACK(I))
          ENDDO
       ENDIF
       
@@ -6102,7 +6115,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       ELSE
          VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
       ENDIF ! do not change capitalization on mesh topology
-      CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', FN_SL3D_VTK(NM), &
+      CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', &
                                         NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
@@ -6376,9 +6389,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
          CLOSE(LU_SLCF(IQ,NM))
       ENDIF
    ENDIF
-
-
-
+   
    ! Dump out the slice file to a .vtk file
 
    IF (VTK3D) THEN
@@ -6407,13 +6418,6 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
             ENDDO
             
             VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=SL%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
-            !IF (VTK_BINARY) THEN
-            !   CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
-            !                             QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
-            !ELSE
-            !   CALL WRITE_VTK_SLICE_DATA(LU_SL3D_VTK(NM), FN_SL3D_VTK(NM),&
-            !                             QQ_PACK, SL%SMOKEVIEW_LABEL(1:30), 'ascii')
-            !ENDIF
             
             DEALLOCATE(QQ_PACK)
          ENDIF
@@ -10739,17 +10743,26 @@ END SUBROUTINE DUMP_MASS
 !> \param T Current simulation time (s)
 !> \param DT Current time step size (s)
 !> \param NM Mesh number
+!> \param IFRMT BNDF (IFRMT=0) or VTK (IFRMT=1)
 
-SUBROUTINE DUMP_BNDF(T,DT,NM)
+SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
 
 REAL(EB), INTENT(IN) :: T,DT
 REAL(FB) :: STIME, BOUND_MIN, BOUND_MAX, BF_FACTOR
-INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2
-INTEGER :: NBF_DEBUG
-INTEGER, INTENT(IN) :: NM
+INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2,ITM,ITM1
+INTEGER :: NBF_DEBUG,IFACT
+INTEGER, INTENT(IN) :: NM,IFRMT
 TYPE(PATCH_TYPE), POINTER :: PA
 REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
 INTEGER :: CHANGE_BOUND, IERROR
+INTEGER :: NX, NY, NZ, NCELLS, NPOINTS
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
+TYPE(VTK_FILE)     :: A_VTK_FILE                    ! A VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+LOGICAL :: VTK_INITIALIZED
 
 IF (MESHES(NM)%N_PATCH==0 .AND. MESHES(NM)%N_INTERNAL_CFACE_CELLS==0) RETURN
 
@@ -10759,20 +10772,271 @@ SUBROUTINE DUMP_BNDF(T,DT,NM)
 
 CALL POINT_TO_MESH(NM)
 
-FILE_LOOP: DO NF=1,N_BNDF
-   IF (N_PATCH == 0) CYCLE FILE_LOOP
-   BF => BOUNDARY_FILE(NF)
-   PY => PROPERTY(BF%PROP_INDEX)
-   BOUND_MAX = -1.0E+33_FB
-   BOUND_MIN = -BOUND_MAX
-   WRITE(LU_BNDF(NF,NM)) STIME
-   IND  = ABS(BF%INDEX)
-   NC = 0
+IF (IFRMT.EQ.0) THEN
+   FILE_LOOP: DO NF=1,N_BNDF
+      IF (N_PATCH == 0) CYCLE FILE_LOOP
+      BF => BOUNDARY_FILE(NF)
+      PY => PROPERTY(BF%PROP_INDEX)
+      BOUND_MAX = -1.0E+33_FB
+      BOUND_MIN = -BOUND_MAX
+      WRITE(LU_BNDF(NF,NM)) STIME
+      IND  = ABS(BF%INDEX)
+      NC = 0
+
+      PATCH_LOOP: DO IP=1,N_PATCH
+
+         PA => PATCH(IP)
+
+         PP  = REAL(OUTPUT_QUANTITY(-IND)%AMBIENT_VALUE,FB)
+         PPN = 0._FB
+         IBK = 0
+
+         ! Adjust PATCH indices depending on orientation
+
+         SELECT CASE(ABS(PA%IOR))
+            CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2
+            CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2
+            CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2
+         END SELECT
+
+         ! Evaluate the given boundary quantity at each cell of the current PATCH
+
+         DO K=PA%KG1,PA%KG2
+            DO J=PA%JG1,PA%JG2
+               DO I=PA%IG1,PA%IG2
+                  IC = CELL_INDEX(I,J,K)
+                  IW = CELL(IC)%WALL_INDEX(-PA%IOR) ; IF (IW==0) CYCLE
+                  SELECT CASE(ABS(PA%IOR))
+                     CASE(1) ; L=J ; N=K
+                     CASE(2) ; L=I ; N=K
+                     CASE(3) ; L=I ; N=J
+                  END SELECT
+                  IF (WALL(IW)%BOUNDARY_TYPE/=NULL_BOUNDARY .AND. &
+                      WALL(IW)%BOUNDARY_TYPE/=INTERPOLATED_BOUNDARY .AND. .NOT.CELL(IC)%SOLID) THEN
+                     IBK(L,N) = 1
+                     PP(L,N)  = REAL(SOLID_PHASE_OUTPUT(NM,IND,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,OPT_WALL_INDEX=IW,&
+                                                        OPT_BNDF_INDEX=NF),FB)
+                  ENDIF
+               ENDDO
+            ENDDO
+         ENDDO
+
+         ! Integrate the boundary quantity in time
+
+         IF (BNDF_COUNTER(NM)>0 .AND. BF%TIME_INTEGRAL_INDEX>0) THEN
+            DO N=N1,N2
+               DO L=L1,L2
+                  NC = NC + 1
+                  BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX) = BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX) + &
+                     PP(L,N)*REAL(BNDF_CLOCK(BNDF_COUNTER(NM))-BNDF_CLOCK(BNDF_COUNTER(NM)-1),FB)
+                  PP(L,N) = BNDF_TIME_INTEGRAL(NC,BF%TIME_INTEGRAL_INDEX)
+               ENDDO
+            ENDDO
+         ENDIF
+
+         ! Interpolate the boundary quantity PP at cell corners, PPN
+
+         IF (.NOT.BF%CELL_CENTERED) THEN
+            DO N=N1-1,N2
+               DO L=L1-1,L2
+                  IF (IBK(L,N)==1)     PPN(L,N) = PPN(L,N) + PP(L,N)
+                  IF (IBK(L+1,N)==1)   PPN(L,N) = PPN(L,N) + PP(L+1,N)
+                  IF (IBK(L,N+1)==1)   PPN(L,N) = PPN(L,N) + PP(L,N+1)
+                  IF (IBK(L+1,N+1)==1) PPN(L,N) = PPN(L,N) + PP(L+1,N+1)
+                  ISUM = IBK(L,N)+IBK(L,N+1)+IBK(L+1,N)+IBK(L+1,N+1)
+                  IF (ISUM>0) THEN
+                     PPN(L,N) = PPN(L,N)/REAL(ISUM,FB)
+                  ELSE
+                     PPN(L,N) = REAL(SOLID_PHASE_OUTPUT(NM,IND,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,OPT_WALL_INDEX=0,&
+                                                        OPT_BNDF_INDEX=NF),FB)
+                  ENDIF
+               ENDDO
+            ENDDO
+            IF (BF%DEBUG .EQ. 0) THEN
+               WRITE(LU_BNDF(NF,NM)) ((PPN(L,N),L=L1-1,L2),N=N1-1,N2)
+               DO L = L1-1, L2
+               DO N = N1-1, N2
+                  BOUND_MIN = MIN(PPN(L,N),BOUND_MIN)
+                  BOUND_MAX = MAX(PPN(L,N),BOUND_MAX)
+               ENDDO
+               ENDDO
+            ELSE
+               NBF_DEBUG = (2+L2-L1)*(2+N2-N1)
+               BF_FACTOR = 0.0_FB
+               IF ( NBF_DEBUG .GT. 1) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB)
+               WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1)
+               BOUND_MIN = -STIME
+               BOUND_MAX =  STIME
+            ENDIF
+
+         ELSE
+            IF (BF%DEBUG .EQ. 0) THEN
+               WRITE(LU_BNDF(NF,NM)) ((PP(L,N),L=L1,L2+1),N=N1,N2+1)
+               DO L = L1, L2+1
+               DO N = N1, N2+1
+                  BOUND_MIN = MIN(PP(L,N),BOUND_MIN)
+                  BOUND_MAX = MAX(PP(L,N),BOUND_MAX)
+               ENDDO
+               ENDDO
+            ELSE
+               NBF_DEBUG = (2+L2-L1)*(2+N2-N1)
+               BF_FACTOR = 0.0_FB
+               IF ( NBF_DEBUG .GT. 1 ) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB)
+               WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1)
+               BOUND_MIN = -STIME
+               BOUND_MAX =  STIME
+            ENDIF
+         ENDIF
 
-   PATCH_LOOP: DO IP=1,N_PATCH
+      ENDDO PATCH_LOOP
+      CHANGE_BOUND = 0
+      IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN
+         BNDF_VAL_MIN = BOUND_MIN
+         BNDF_VAL_MAX = BOUND_MAX
+         CHANGE_BOUND = 1
+      ELSE
+         OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),ACTION='READ')
+         READ(LU_BNDF(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
+         CLOSE(LU_BNDF(NF+N_BNDF,NM))
+         IF( IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN
+            BNDF_VAL_MIN = BOUND_MIN
+            CHANGE_BOUND = 1
+         ENDIF
+         IF( IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN
+            BNDF_VAL_MAX = BOUND_MAX
+            CHANGE_BOUND = 1
+         ENDIF
+      ENDIF
+      IF (CHANGE_BOUND == 1) THEN
+         OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE')
+         WRITE(LU_BNDF(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)')STIME, BNDF_VAL_MIN, BNDF_VAL_MAX
+         CLOSE(LU_BNDF(NF+N_BNDF,NM))
+      ENDIF
+
+   ENDDO FILE_LOOP
 
+   IF (CC_IBM) THEN
+      FILE_LOOP2 : DO NF=1,N_BNDF
+         BF => BOUNDARY_FILE(NF)
+         PY => PROPERTY(BF%PROP_INDEX)
+         IND  = ABS(BF%INDEX)
+         NC = 0
+         I1=0; I2=-1; J1=0; J2=-1; K1=0; K2=-1; ! Just dummy numbers, not needed for INBOUND_FACES
+         ! write geometry for slice file
+         CHANGE_BOUND = 0
+         IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN
+            OPEN(LU_BNDG(NF,NM),       FILE=FN_BNDG(NF,NM),       FORM='UNFORMATTED',STATUS='REPLACE')
+            CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), &
+                                      .FALSE.,.TRUE.,"INBOUND_FACES",1,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, &
+                                      IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, &
+                                      BOUND_MIN, BOUND_MAX)
+            BNDF_VAL_MIN = BOUND_MIN
+            BNDF_VAL_MAX = BOUND_MAX
+            CHANGE_BOUND = 1
+         ELSE
+            ! data file at subsequent time steps
+            OPEN(LU_BNDG(NF,NM),       FILE=FN_BNDG(NF,NM),       FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
+            CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), &
+                            .FALSE.,.TRUE.,"INBOUND_FACES",0,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, &
+                            IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, &
+                            BOUND_MIN, BOUND_MAX)
+            OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM), ACTION='READ')
+            READ(LU_BNDG(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
+            CLOSE(LU_BNDG(NF+N_BNDF,NM))
+            IF (IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN
+              BNDF_VAL_MIN = BOUND_MIN
+              CHANGE_BOUND = 1
+            ENDIF
+            IF (IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN
+              BNDF_VAL_MAX = BOUND_MAX
+              CHANGE_BOUND = 1
+            ENDIF
+         ENDIF
+         IF (CHANGE_BOUND == 1) THEN
+            OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE')
+            WRITE(LU_BNDG(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)') STIME, BNDF_VAL_MIN, BNDF_VAL_MAX
+            CLOSE(LU_BNDG(NF+N_BNDF,NM))
+         ENDIF
+         CLOSE(LU_BNDG(NF,NM))
+      ENDDO FILE_LOOP2
+   ENDIF
+ELSEIF (IFRMT.EQ.1) THEN
+   ITM  = INT(STIME)
+   ITM1 = NINT(ABS(STIME-ITM)*100)
+   IF (ITM1==100) THEN
+      ITM = ITM+1
+      ITM1 = 0
+   ENDIF
+   WRITE(FN_BNDF_VTK(NM),'(A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_BNDF_',NM,'_',ITM,ITM1,'.vtu'
+   IF (VTK_BINARY) THEN
+      VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_BNDF_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+   ELSE
+      VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_BNDF_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
+   ENDIF ! do not change capitalization on mesh topology
+   PATCH_LOOP1: DO IP=1,N_PATCH
       PA => PATCH(IP)
+      ! Initialize piece
+      CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, 'UnstructuredGrid', NCELLS, NPOINTS, &
+                                          X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)          
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
+      VTK_INITIALIZED=.TRUE.
+      CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+      
+      ! Loop through cell centered = F
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN')
+      FILE_LOOPA: DO NF=1,N_BNDF
+         IF (N_PATCH == 0) CYCLE FILE_LOOPA
+         BF => BOUNDARY_FILE(NF)
+         IF (BF%CELL_CENTERED) CYCLE FILE_LOOPA
+         PY => PROPERTY(BF%PROP_INDEX)
+         BOUND_MAX = -1.0E+33_FB
+         BOUND_MIN = -BOUND_MAX
+         IND  = ABS(BF%INDEX)
+                  
+         CALL PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK)
+         
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
+         DEALLOCATE(QQ_PACK)
+      ENDDO FILE_LOOPA
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE')
+      
+      ! Loop through cell centered = T
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='OPEN')
+      FILE_LOOPB: DO NF=1,N_BNDF
+         IF (N_PATCH == 0) CYCLE FILE_LOOPB
+         BF => BOUNDARY_FILE(NF)
+         IF (.NOT.BF%CELL_CENTERED) CYCLE FILE_LOOPB
+         PY => PROPERTY(BF%PROP_INDEX)
+         BOUND_MAX = -1.0E+33_FB
+         BOUND_MIN = -BOUND_MAX
+         IND  = ABS(BF%INDEX)
+                  
+         CALL PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK)
+         
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=QQ_PACK)
+         DEALLOCATE(QQ_PACK)
+      ENDDO FILE_LOOPB
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+   ENDDO PATCH_LOOP1
+   VTK_ERROR = A_VTK_FILE%FINALIZE()
+ENDIF
 
+FROM_BNDF = .FALSE.
+
+CONTAINS
+
+   SUBROUTINE PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK)
+      IMPLICIT NONE
+      TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA
+      TYPE(BOUNDARY_FILE_TYPE), POINTER, INTENT(IN) :: BF
+      REAL(FB), POINTER, DIMENSION(:,:), INTENT(IN) :: PP,PPN
+      INTEGER, INTENT(IN) :: IND
+      INTEGER :: ISUM,I,J,K,L,L1,L2,N,N1,N2
+      REAL(FB), ALLOCATABLE, DIMENSION(:), INTENT(OUT) :: QQ_PACK
+      
       PP  = REAL(OUTPUT_QUANTITY(-IND)%AMBIENT_VALUE,FB)
       PPN = 0._FB
       IBK = 0
@@ -10838,116 +11102,35 @@ SUBROUTINE DUMP_BNDF(T,DT,NM)
                ENDIF
             ENDDO
          ENDDO
-         IF (BF%DEBUG .EQ. 0) THEN
-            WRITE(LU_BNDF(NF,NM)) ((PPN(L,N),L=L1-1,L2),N=N1-1,N2)
-            DO L = L1-1, L2
-            DO N = N1-1, N2
-               BOUND_MIN = MIN(PPN(L,N),BOUND_MIN)
-               BOUND_MAX = MAX(PPN(L,N),BOUND_MAX)
-            ENDDO
+      ENDIF
+      
+      SELECT CASE(ABS(PA%IOR))
+         CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2;
+         CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2;
+         CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2;
+      END SELECT
+      NPOINTS = (L2-L1+2)*(N2-N1+2)
+      NCELLS = (L2-L1+1)*(N2-N1+1)
+      IFACT = 1
+      IF (.NOT.BF%CELL_CENTERED) THEN
+         ALLOCATE(QQ_PACK(NPOINTS))
+         DO N = N1-1,N2
+            DO L = L1-1,L2
+               QQ_PACK(IFACT)=PPN(L,N)
+               IFACT = IFACT+1
             ENDDO
-         ELSE
-            NBF_DEBUG = (2+L2-L1)*(2+N2-N1)
-            BF_FACTOR = 0.0_FB
-            IF ( NBF_DEBUG .GT. 1) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB)
-            WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1)
-            BOUND_MIN = -STIME
-            BOUND_MAX =  STIME
-         ENDIF
-
+         ENDDO
       ELSE
-         IF (BF%DEBUG .EQ. 0) THEN
-            WRITE(LU_BNDF(NF,NM)) ((PP(L,N),L=L1,L2+1),N=N1,N2+1)
-            DO L = L1, L2+1
-            DO N = N1, N2+1
-               BOUND_MIN = MIN(PP(L,N),BOUND_MIN)
-               BOUND_MAX = MAX(PP(L,N),BOUND_MAX)
-            ENDDO
+         ALLOCATE(QQ_PACK(NCELLS))
+         DO L = L1,L2
+            DO N = N1,N2
+               QQ_PACK(IFACT)=PP(L,N)
+               IFACT = IFACT+1
             ENDDO
-         ELSE
-            NBF_DEBUG = (2+L2-L1)*(2+N2-N1)
-            BF_FACTOR = 0.0_FB
-            IF ( NBF_DEBUG .GT. 1 ) BF_FACTOR = 2.0_FB*STIME/REAL(NBF_DEBUG-1,FB)
-            WRITE(LU_BNDF(NF,NM)) (REAL(-STIME+L*BF_FACTOR,FB),L=0,NBF_DEBUG-1)
-            BOUND_MIN = -STIME
-            BOUND_MAX =  STIME
-         ENDIF
-      ENDIF
-
-   ENDDO PATCH_LOOP
-   CHANGE_BOUND = 0
-   IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN
-      BNDF_VAL_MIN = BOUND_MIN
-      BNDF_VAL_MAX = BOUND_MAX
-      CHANGE_BOUND = 1
-   ELSE
-      OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),ACTION='READ')
-      READ(LU_BNDF(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
-      CLOSE(LU_BNDF(NF+N_BNDF,NM))
-      IF( IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN
-         BNDF_VAL_MIN = BOUND_MIN
-         CHANGE_BOUND = 1
-      ENDIF
-      IF( IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN
-         BNDF_VAL_MAX = BOUND_MAX
-         CHANGE_BOUND = 1
-      ENDIF
-   ENDIF
-   IF (CHANGE_BOUND == 1) THEN
-      OPEN(LU_BNDF(NF+N_BNDF,NM),FILE=FN_BNDF(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE')
-      WRITE(LU_BNDF(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)')STIME, BNDF_VAL_MIN, BNDF_VAL_MAX
-      CLOSE(LU_BNDF(NF+N_BNDF,NM))
-   ENDIF
-
-ENDDO FILE_LOOP
-
-IF (CC_IBM) THEN
-   FILE_LOOP2 : DO NF=1,N_BNDF
-      BF => BOUNDARY_FILE(NF)
-      PY => PROPERTY(BF%PROP_INDEX)
-      IND  = ABS(BF%INDEX)
-      NC = 0
-      I1=0; I2=-1; J1=0; J2=-1; K1=0; K2=-1; ! Just dummy numbers, not needed for INBOUND_FACES
-      ! write geometry for slice file
-      CHANGE_BOUND = 0
-      IF (REAL(T-T_BEGIN,FB)<TWO_EPSILON_FB) THEN
-         OPEN(LU_BNDG(NF,NM),       FILE=FN_BNDG(NF,NM),       FORM='UNFORMATTED',STATUS='REPLACE')
-         CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), &
-                                   .FALSE.,.TRUE.,"INBOUND_FACES",1,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, &
-                                   IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, &
-                                   BOUND_MIN, BOUND_MAX)
-         BNDF_VAL_MIN = BOUND_MIN
-         BNDF_VAL_MAX = BOUND_MAX
-         CHANGE_BOUND = 1
-      ELSE
-         ! data file at subsequent time steps
-         OPEN(LU_BNDG(NF,NM),       FILE=FN_BNDG(NF,NM),       FORM='UNFORMATTED',STATUS='OLD',POSITION='APPEND')
-         CALL DUMP_SLICE_GEOM_DATA(LU_BNDG(NF,NM), &
-                         .FALSE.,.TRUE.,"INBOUND_FACES",0,STIME,I1,I2,J1,J2,K1,K2,BF%DEBUG, &
-                         IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM, &
-                         BOUND_MIN, BOUND_MAX)
-         OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM), ACTION='READ')
-         READ(LU_BNDG(NF+N_BNDF,NM),FMT=*,IOSTAT=IERROR)BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
-         CLOSE(LU_BNDG(NF+N_BNDF,NM))
-         IF (IERROR /= 0 .OR. BOUND_MIN < BNDF_VAL_MIN) THEN
-           BNDF_VAL_MIN = BOUND_MIN
-           CHANGE_BOUND = 1
-         ENDIF
-         IF (IERROR /= 0 .OR. BOUND_MAX > BNDF_VAL_MAX) THEN
-           BNDF_VAL_MAX = BOUND_MAX
-           CHANGE_BOUND = 1
-         ENDIF
-      ENDIF
-      IF (CHANGE_BOUND == 1) THEN
-         OPEN(LU_BNDG(NF+N_BNDF,NM),FILE=FN_BNDG(NF+N_BNDF,NM),FORM='FORMATTED',STATUS='REPLACE')
-         WRITE(LU_BNDG(NF+N_BNDF,NM),'(ES13.6,1X,ES13.6,1X,ES13.6)') STIME, BNDF_VAL_MIN, BNDF_VAL_MAX
-         CLOSE(LU_BNDG(NF+N_BNDF,NM))
+         ENDDO
       ENDIF
-      CLOSE(LU_BNDG(NF,NM))
-   ENDDO FILE_LOOP2
-ENDIF
 
-FROM_BNDF = .FALSE.
+   END SUBROUTINE PACK_VTK_BNDF
 
 END SUBROUTINE DUMP_BNDF
 
diff --git a/Source/func.f90 b/Source/func.f90
index ead15d3c3dd..2a987d361a0 100644
--- a/Source/func.f90
+++ b/Source/func.f90
@@ -483,6 +483,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T)
 CALL SET_OUTPUT_CLOCK(DT_SPEC   ,RAMP_SPEC_INDEX,SPEC_CLOCK,SPEC_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SL3D_VTK_INDEX,  SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SM3D_VTK_INDEX,  SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. )
+CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_BNDF_VTK_INDEX,  BNDF_VTK_CLOCK, BNDF_VTK_COUNTER,.TRUE. ,.TRUE. )
 
 ! Special cases
 
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 59943682cd5..73b3e802135 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -382,31 +382,7 @@ MODULE PENF_STRINGIFY
 IMPLICIT NONE
 PRIVATE
 SAVE
-PUBLIC :: STR_ASCII, STR_UCS4
-PUBLIC :: STR, STRZ, CTON
-PUBLIC :: BSTR, BCTON
-
-INTERFACE STR_ASCII
-   !< CONVERT STRING OF ANY KIND TO ASCII STRING.
-   MODULE PROCEDURE STR_ASCII_DEFAULT
-#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT
-   MODULE PROCEDURE STR_ASCII_ASCII
-#endif
-#ifdef _UCS4_SUPPORTED
-   MODULE PROCEDURE STR_ASCII_UCS4
-#endif
-ENDINTERFACE
-
-INTERFACE STR_UCS4
-   !< CONVERT STRING OF ANY KIND TO UCS4 STRING.
-   MODULE PROCEDURE STR_UCS4_DEFAULT
-#if defined _ASCII_SUPPORTED && defined _ASCII_NEQ_DEFAULT
-   MODULE PROCEDURE STR_UCS4_ASCII
-#endif
-#ifdef _UCS4_SUPPORTED
-   MODULE PROCEDURE STR_UCS4_UCS4
-#endif
-ENDINTERFACE
+PUBLIC :: STR
 
 INTERFACE STR
   !< CONVERT NUMBER (REAL AND INTEGER) TO STRING (NUMBER TO STRING TYPE CASTING).
@@ -428,143 +404,9 @@ MODULE PENF_STRINGIFY
                              STR_A_I1P
 ENDINTERFACE
 
-INTERFACE STRZ
-  !< CONVERT INTEGER, TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS (INTEGER TO STRING TYPE CASTING WITH ZERO PADDING).
-  MODULE PROCEDURE STRZ_I8P, STRZ_I4P, STRZ_I2P, STRZ_I1P
-ENDINTERFACE
-
-INTERFACE CTON
-  !< CONVERT STRING TO NUMBER (REAL AND INTEGER, STRING TO NUMBER TYPE CASTING).
-  MODULE PROCEDURE            &
-                   CTOR_R16P, &
-                   CTOR_R8P,  &
-                   CTOR_R4P,  &
-                   CTOI_I8P,  &
-                   CTOI_I4P,  &
-                   CTOI_I2P,  &
-                   CTOI_I1P
-ENDINTERFACE
-
-INTERFACE BSTR
-  !< CONVERT NUMBER (REAL AND INTEGER) TO BIT-STRING (NUMBER TO BIT-STRING TYPE CASTING).
-  MODULE PROCEDURE            &
-                   BSTR_R16P, &
-                   BSTR_R8P,  &
-                   BSTR_R4P,  &
-                   BSTR_I8P,  &
-                   BSTR_I4P,  &
-                   BSTR_I2P,  &
-                   BSTR_I1P
-ENDINTERFACE
 
-INTERFACE BCTON
-  !< CONVERT BIT-STRING TO NUMBER (REAL AND INTEGER, BIT-STRING TO NUMBER TYPE CASTING).
-  MODULE PROCEDURE             &
-                   BCTOR_R16P, &
-                   BCTOR_R8P,  &
-                   BCTOR_R4P,  &
-                   BCTOI_I8P,  &
-                   BCTOI_I4P,  &
-                   BCTOI_I2P,  &
-                   BCTOI_I1P
-ENDINTERFACE
 
 CONTAINS
-   PURE FUNCTION STR_ASCII_DEFAULT(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF DEFAULT KIND TO ASCII STRING.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM ASCII')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS DEFAULT KIND, BUT NOW I AM ASCII <<<
-   CHARACTER(LEN=*), INTENT(IN)              :: INPUT  !< INPUT STRING OF DEFAULT KIND.
-   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_ASCII_DEFAULT
-
-   PURE FUNCTION STR_ASCII_ASCII(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF ASCII KIND TO ASCII STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII('I WAS ASCII KIND AND I AM STILL ASCII')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS ASCII KIND AND I AM STILL ASCII <<<
-   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN)  :: INPUT  !< INPUT STRING OF ASCII KIND.
-   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_ASCII_ASCII
-
-   PURE FUNCTION STR_ASCII_UCS4(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF UCS4 KIND TO ASCII STRING.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND, BUT NOW I AM ASCII')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS UCS4 KIND, BUT NOW I AM ASCII <<<
-   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)   :: INPUT  !< INPUT STRING OF UCS4 KIND.
-   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF ASCII KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_ASCII_UCS4
-
-   PURE FUNCTION STR_UCS4_DEFAULT(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF DEFAULT KIND TO UCS4 STRING.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII('I WAS DEFAULT KIND, BUT NOW I AM UCS4')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS DEFAULT KIND, BUT NOW I AM UCS4 <<<
-   CHARACTER(LEN=*), INTENT(IN)             :: INPUT  !< INPUT STRING OF DEFAULT KIND.
-   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_UCS4_DEFAULT
-
-   PURE FUNCTION STR_UCS4_ASCII(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF ASCII KIND TO UCS4 STRING.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII(ASCII_'I WAS ASCII KIND, BUT NOW I AM UCS4')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS ASCII KIND, BUT NOW I AM UCS4 <<<
-   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN) :: INPUT  !< INPUT STRING OF ASCII KIND.
-   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_UCS4_ASCII
-
-   PURE FUNCTION STR_UCS4_UCS4(INPUT) RESULT(OUTPUT)
-   !< CONVERT STRING OF UCS4 KIND TO UCS4 STRING, JUST FOR CONVENIENCE IN SANITIZE STRINGS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: STRING
-   !< STRING = STR_ASCII(UCS4_'I WAS UCS4 KIND AND I AM STILL UCS4')
-   !< PRINT "(A)", STRING
-   !<```
-   !=> I WAS UCS4 KIND AND I AM STILL UCS4 <<<
-   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)  :: INPUT  !< INPUT STRING OF UCS4 KIND.
-   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE :: OUTPUT !< OUTPUT STRING OF UCS4 KIND.
-
-   OUTPUT = INPUT
-   ENDFUNCTION STR_UCS4_UCS4
 
    ELEMENTAL FUNCTION STRF_R16P(FM, N) RESULT(STR)
    !< CONVERT REAL TO STRING.
@@ -1315,497 +1157,7 @@ PURE SUBROUTINE COMPACT_REAL_STRING(STRING)
    ENDIF
    ENDSUBROUTINE COMPACT_REAL_STRING
 
-   ELEMENTAL FUNCTION STRZ_I8P(N, NZ_PAD) RESULT(STR)
-   !< CONVERTING INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I8P)
-   !<```
-   !=> 0000000000000000001 <<<
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I8P, NZ_PAD=5)
-   !<```
-   !=> 00001 <<<
-   INTEGER(I8P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
-   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
-   CHARACTER(DI8P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
-
-   WRITE(STR,FI8PZP) N                              ! CASTING OF N TO STRING.
-   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
-   IF (PRESENT(NZ_PAD)) STR=STR(DI8P-NZ_PAD:DI8P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
-   ENDFUNCTION STRZ_I8P
-
-   ELEMENTAL FUNCTION STRZ_I4P(N, NZ_PAD) RESULT(STR)
-   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I4P)
-   !<```
-   !=> 0000000001 <<<
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I4P, NZ_PAD=5)
-   !<```
-   !=> 00001 <<<
-   INTEGER(I4P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
-   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
-   CHARACTER(DI4P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
-
-   WRITE(STR,FI4PZP) N                              ! CASTING OF N TO STRING.
-   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
-   IF (PRESENT(NZ_PAD)) STR=STR(DI4P-NZ_PAD:DI4P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
-   ENDFUNCTION STRZ_I4P
-
-   ELEMENTAL FUNCTION STRZ_I2P(N, NZ_PAD) RESULT(STR)
-   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I2P)
-   !<```
-   !=> 00001 <<<
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I2P, NZ_PAD=3)
-   !<```
-   !=> 001 <<<
-   INTEGER(I2P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
-   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
-   CHARACTER(DI2P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
-
-   WRITE(STR,FI2PZP) N                              ! CASTING OF N TO STRING.
-   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
-   IF (PRESENT(NZ_PAD)) STR=STR(DI2P-NZ_PAD:DI2P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
-   ENDFUNCTION STRZ_I2P
-
-   ELEMENTAL FUNCTION STRZ_I1P(N, NZ_PAD) RESULT(STR)
-   !< CONVERT INTEGER TO STRING, PREFIXING WITH THE RIGHT NUMBER OF ZEROS.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I1P)
-   !<```
-   !=> 001 <<<
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", STRZ(N=1_I1P, NZ_PAD=3)
-   !<```
-   !=> 001 <<<
-   INTEGER(I1P), INTENT(IN)           :: N      !< INTEGER TO BE CONVERTED.
-   INTEGER(I4P), INTENT(IN), OPTIONAL :: NZ_PAD !< NUMBER OF ZEROS PADDING.
-   CHARACTER(DI1P)                    :: STR    !< RETURNED STRING CONTAINING INPUT NUMBER PLUS PADDING ZEROS.
-
-   WRITE(STR,FI1PZP) N                              ! CASTING OF N TO STRING.
-   STR=STR(2:)                                      ! LEAVING OUT THE SIGN.
-   IF (PRESENT(NZ_PAD)) STR=STR(DI1P-NZ_PAD:DI1P-1) ! LEAVING OUT THE EXTRA ZEROS PADDING
-   ENDFUNCTION STRZ_I1P
-
-   FUNCTION CTOR_R16P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR16P, CTON(STR='-1.0', KND=1._R16P)
-   !<```
-   !=> -0.100000000000000000000000000000000E+0001 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   REAL(R16P),             INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   REAL(R16P)                          :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOR_R16P
-
-   FUNCTION CTOR_R8P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR8P, CTON(STR='-1.0', KND=1._R8P)
-   !<```
-   !=> -0.100000000000000E+001 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   REAL(R8P),              INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   REAL(R8P)                           :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOR_R8P
-
-   FUNCTION CTOR_R4P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR4P, CTON(STR='-1.0', KND=1._R4P)
-   !<```
-   !=> -0.100000E+01 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   REAL(R4P),              INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   REAL(R4P)                           :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO REAL FAILED! REAL(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOR_R4P
-
-   FUNCTION CTOI_I8P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI8P, CTON(STR='-1', KND=1_I8P)
-   !<```
-   !=> -1 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I8P),           INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   INTEGER(I8P)                        :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOI_I8P
-
-   FUNCTION CTOI_I4P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI4P, CTON(STR='-1', KND=1_I4P)
-   !<```
-   !=> -1 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I4P),           INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   INTEGER(I4P)                        :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOI_I4P
-
-   FUNCTION CTOI_I2P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI2P, CTON(STR='-1', KND=1_I2P)
-   !<```
-   !=> -1 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I2P),           INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   INTEGER(I2P)                        :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOI_I2P
-
-   FUNCTION CTOI_I1P(STR, KND, PREF, ERROR) RESULT(N)
-   !< CONVERT STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI1P, CTON(STR='-1', KND=1_I1P)
-   !<```
-   !=> -1 <<<
-   CHARACTER(*),           INTENT(IN)  :: STR   !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I1P),           INTENT(IN)  :: KND   !< NUMBER KIND.
-   CHARACTER(*), OPTIONAL, INTENT(IN)  :: PREF  !< PREFIXING STRING.
-   INTEGER(I4P), OPTIONAL, INTENT(OUT) :: ERROR !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   INTEGER(I1P)                        :: N     !< NUMBER RETURNED.
-   INTEGER(I4P)                        :: ERR   !< ERROR TRAPPING FLAG: 0 NO ERRORS, >0 ERROR OCCURS.
-   CHARACTER(LEN=:), ALLOCATABLE       :: PREFD !< PREFIXING STRING.
-
-   READ(STR, *, IOSTAT=ERR) N ! CASTING OF STR TO N.
-   IF (ERR/=0) THEN
-     PREFD = '' ; IF (PRESENT(PREF)) PREFD = PREF
-     WRITE(STDERR, '(A,I1,A)') PREFD//' ERROR: CONVERSION OF STRING "'//STR//'" TO INTEGER FAILED! INTEGER(', KIND(KND), ')'
-   ENDIF
-   IF (PRESENT(ERROR)) ERROR = ERR
-   ENDFUNCTION CTOI_I1P
-
-   ELEMENTAL FUNCTION BSTR_R16P(N) RESULT(BSTR)
-   !< CONVERT REAL TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT R16P IS REPRESENTED BY MEANS OF 128 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< CHARACTER(128) :: B
-   !< B = BSTR(N=1._R16P)
-   !< PRINT "(A)", B(17:)
-   !<```
-   !=> 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111111100111111 <<<
-   REAL(R16P), INTENT(IN) :: N          !< REAL TO BE CONVERTED.
-   CHARACTER(128)         :: BSTR       !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-   INTEGER(I1P)           :: BUFFER(16) !< TRANSFER BUFFER.
-
-   BUFFER = TRANSFER(N, BUFFER)
-   WRITE(BSTR, '(16B8.8)') BUFFER
-   ENDFUNCTION BSTR_R16P
-
-   ELEMENTAL FUNCTION BSTR_R8P(N) RESULT(BSTR)
-   !< CONVERT REAL TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT R8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1._R8P)
-   !<```
-   !=> 0000000000000000000000000000000000000000000000001111000000111111 <<<
-   REAL(R8P), INTENT(IN) :: N         !< REAL TO BE CONVERTED.
-   CHARACTER(64)         :: BSTR      !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-   INTEGER(I1P)          :: BUFFER(8) !< TRANSFER BUFFER.
-
-   BUFFER = TRANSFER(N, BUFFER)
-   WRITE(BSTR, '(8B8.8)') BUFFER
-   ENDFUNCTION BSTR_R8P
-
-   ELEMENTAL FUNCTION BSTR_R4P(N) RESULT(BSTR)
-   !< CONVERT REAL TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT R4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1._R4P)
-   !<```
-   !=> 00000000000000001000000000111111 <<<
-   REAL(R4P), INTENT(IN) :: N         !< REAL TO BE CONVERTED.
-   CHARACTER(32)         :: BSTR      !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-   INTEGER(I1P)          :: BUFFER(4) !< TRANSFER BUFFER.
-
-   BUFFER = TRANSFER(N, BUFFER)
-   WRITE(BSTR, '(4B8.8)') BUFFER
-   ENDFUNCTION BSTR_R4P
-
-   ELEMENTAL FUNCTION BSTR_I8P(N) RESULT(BSTR)
-   !< CONVERT INTEGER TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT I8P IS REPRESENTED BY MEANS OF 64 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1_I8P)
-   !<```
-   !=> 0000000000000000000000000000000000000000000000000000000000000001 <<<
-   INTEGER(I8P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
-   CHARACTER(64)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-
-   WRITE(BSTR, '(B64.64)') N
-   ENDFUNCTION BSTR_I8P
-
-   ELEMENTAL FUNCTION BSTR_I4P(N) RESULT(BSTR)
-   !< CONVERT INTEGER TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT I4P IS REPRESENTED BY MEANS OF 32 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1_I4P)
-   !<```
-   !=> 00000000000000000000000000000001 <<<
-   INTEGER(I4P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
-   CHARACTER(32)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-
-   WRITE(BSTR, '(B32.32)') N
-   ENDFUNCTION BSTR_I4P
-
-   ELEMENTAL FUNCTION BSTR_I2P(N) RESULT(BSTR)
-   !< CONVERT INTEGER TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT I2P IS REPRESENTED BY MEANS OF 16 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1_I2P)
-   !<```
-   !=> 0000000000000001 <<<
-   INTEGER(I2P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
-   CHARACTER(16)            :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-
-   WRITE(BSTR, '(B16.16)') N
-   ENDFUNCTION BSTR_I2P
-
-   ELEMENTAL FUNCTION BSTR_I1P(N) RESULT(BSTR)
-   !< CONVERT INTEGER TO STRING OF BITS.
-   !<
-   !< @NOTE IT IS ASSUMED THAT I1P IS REPRESENTED BY MEANS OF 8 BITS, BUT THIS IS NOT ENSURED IN ALL ARCHITECTURES.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT "(A)", BSTR(N=1_I1P)
-   !<```
-   !=> 00000001 <<<
-   INTEGER(I1P), INTENT(IN) :: N    !< REAL TO BE CONVERTED.
-   CHARACTER(8)             :: BSTR !< RETURNED BIT-STRING CONTAINING INPUT NUMBER.
-
-   WRITE(BSTR, '(B8.8)') N
-   ENDFUNCTION BSTR_I1P
-
-   ELEMENTAL FUNCTION BCTOR_R16P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR16P, BCTON('00000000000000000000000000000000000000000000000000000000000000000000000000000'//&
-   !<                    '000000000000000000000000000000000001111111100111111', KND=1._R16P)
-   !<```
-   !=> 0.100000000000000000000000000000000E+0001 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR       !< STRING CONTAINING INPUT NUMBER.
-   REAL(R16P),   INTENT(IN) :: KND        !< NUMBER KIND.
-   REAL(R16P)               :: N          !< NUMBER RETURNED.
-   INTEGER(I1P)             :: BUFFER(16) !< TRANSFER BUFFER.
-
-   READ(BSTR, '(16B8.8)') BUFFER
-   N = TRANSFER(BUFFER, N)
-   ENDFUNCTION BCTOR_R16P
-
-   ELEMENTAL FUNCTION BCTOR_R8P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR8P, BCTON('0000000000000000000000000000000000000000000000001111000000111111', KND=1._R8P)
-   !<```
-   !=> 0.100000000000000E+001 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR      !< STRING CONTAINING INPUT NUMBER.
-   REAL(R8P),    INTENT(IN) :: KND       !< NUMBER KIND.
-   REAL(R8P)                :: N         !< NUMBER RETURNED.
-   INTEGER(I1P)             :: BUFFER(8) !< TRANSFER BUFFER.
-
-   READ(BSTR, '(8B8.8)') BUFFER
-   N = TRANSFER(BUFFER, N)
-   ENDFUNCTION BCTOR_R8P
-
-   ELEMENTAL FUNCTION BCTOR_R4P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO REAL.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FR4P, BCTON('00000000000000001000000000111111', KND=1._R4P)
-   !<```
-   !=> 0.100000E+01 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR      !< STRING CONTAINING INPUT NUMBER.
-   REAL(R4P),    INTENT(IN) :: KND       !< NUMBER KIND.
-   REAL(R4P)                :: N         !< NUMBER RETURNED.
-   INTEGER(I1P)             :: BUFFER(4) !< TRANSFER BUFFER.
-
-   READ(BSTR, '(4B8.8)') BUFFER
-   N = TRANSFER(BUFFER, N)
-   ENDFUNCTION BCTOR_R4P
-
-   ELEMENTAL FUNCTION BCTOI_I8P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI8P, BCTON('0000000000000000000000000000000000000000000000000000000000000001', KND=1_I8P)
-   !<```
-   !=> 1 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I8P), INTENT(IN) :: KND  !< NUMBER KIND.
-   INTEGER(I8P)             :: N    !< NUMBER RETURNED.
-
-   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
-   ENDFUNCTION BCTOI_I8P
-
-   ELEMENTAL FUNCTION BCTOI_I4P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI4P, BCTON('00000000000000000000000000000001', KND=1_I4P)
-   !<```
-   !=> 1 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I4P), INTENT(IN) :: KND  !< NUMBER KIND.
-   INTEGER(I4P)             :: N    !< NUMBER RETURNED.
-
-   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
-   ENDFUNCTION BCTOI_I4P
-
-   ELEMENTAL FUNCTION BCTOI_I2P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI2P, BCTON('0000000000000001', KND=1_I2P)
-   !<```
-   !=> 1 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I2P), INTENT(IN) :: KND  !< NUMBER KIND.
-   INTEGER(I2P)             :: N    !< NUMBER RETURNED.
-
-   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
-   ENDFUNCTION BCTOI_I2P
-
-   ELEMENTAL FUNCTION BCTOI_I1P(BSTR, KND) RESULT(N)
-   !< CONVERT BIT-STRING TO INTEGER.
-   !<
-   !<```FORTRAN
-   !< USE PENF
-   !< PRINT FI1P, BCTON('00000001', KND=1_I1P)
-   !<```
-   !=> 1 <<<
-   CHARACTER(*), INTENT(IN) :: BSTR !< STRING CONTAINING INPUT NUMBER.
-   INTEGER(I1P), INTENT(IN) :: KND  !< NUMBER KIND.
-   INTEGER(I1P)             :: N    !< NUMBER RETURNED.
 
-   READ(BSTR,'(B'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//'.'//TRIM(STR(BIT_SIZE(KND), .TRUE.))//')') N
-   ENDFUNCTION BCTOI_I1P
 ENDMODULE PENF_STRINGIFY
 
 
@@ -1819,7 +1171,7 @@ MODULE PENF
 #else
 USE PENF_B_SIZE, ONLY : BIT_SIZE, BYTE_SIZE
 #endif
-USE PENF_STRINGIFY, ONLY : STR_ASCII, STR_UCS4, STR, STRZ, CTON, BSTR, BCTON
+USE PENF_STRINGIFY, ONLY : STR
 
 IMPLICIT NONE
 PRIVATE
@@ -1841,9 +1193,7 @@ MODULE PENF
 ! BIT/BYTE SIZE FUNCTIONS
 PUBLIC :: BIT_SIZE, BYTE_SIZE
 ! STRINGIFY FACILITY
-PUBLIC :: STR_ASCII, STR_UCS4
-PUBLIC :: STR, STRZ, CTON
-PUBLIC :: BSTR, BCTON
+PUBLIC :: STR
 ! MISCELLANEA FACILITY
 PUBLIC :: CHECK_ENDIAN
 PUBLIC :: DIGIT
@@ -19295,7 +18645,7 @@ MODULE VTK_FDS_INTERFACE
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
-PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,&
+PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
        WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,&
        DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
 
@@ -19484,14 +18834,14 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
 
 
 
-SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, &
+SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, &
                                         NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
 
 INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY, FN
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 INTEGER, INTENT(IN) :: NM
 
 NX = SIZE(MESHES(NM)%X)
@@ -19548,14 +18898,92 @@ SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, FN, &
 ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY
          
 
+SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, &
+                                          NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+
+INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+INTEGER, INTENT(IN) :: NM
+TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA
+
+! Fill point data
+SELECT CASE(ABS(PA%IOR))
+   CASE(1) ; L1=PA%JG1 ; L2=PA%JG2 ; N1=PA%KG1 ; N2=PA%KG2 ; NX=1; NY=(L2-L1); NZ=(N2-N1)
+   CASE(2) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%KG1 ; N2=PA%KG2 ; NX=(L2-L1); NY=1; NZ=(N2-N1)
+   CASE(3) ; L1=PA%IG1 ; L2=PA%IG2 ; N1=PA%JG1 ; N2=PA%JG2 ; NX=(L2-L1); NY=(N2-N1); NZ=1
+END SELECT
+NPOINTS = (L2-L1+2)*(N2-N1+2)
+NCELLS = (L2-L1+1)*(N2-N1+1)
+ALLOCATE(X_PTS(NPOINTS))
+ALLOCATE(Y_PTS(NPOINTS))
+ALLOCATE(Z_PTS(NPOINTS))
+ALLOCATE(CONNECT(NCELLS*4))
+ALLOCATE(OFFSETS(NCELLS))
+ALLOCATE(VTKC_TYPE(NCELLS))
+IFACT = 1
+SELECT CASE(ABS(PA%IOR))
+   CASE(1)
+      DO K = PA%K1,PA%K2
+         DO J = PA%J1,PA%J2
+            X_PTS(IFACT)=MESHES(NM)%X(PA%I1)
+            Y_PTS(IFACT)=MESHES(NM)%Y(J)
+            Z_PTS(IFACT)=MESHES(NM)%Z(K)
+            IFACT = IFACT + 1
+         ENDDO
+      ENDDO
+   CASE(2)
+      DO K = PA%K1,PA%K2
+         DO I = PA%I1,PA%I2
+            X_PTS(IFACT)=MESHES(NM)%X(I)
+            Y_PTS(IFACT)=MESHES(NM)%Y(PA%J1)
+            Z_PTS(IFACT)=MESHES(NM)%Z(K)
+            IFACT = IFACT + 1
+         ENDDO
+      ENDDO
+   CASE(3)
+      DO J = PA%J1,PA%J2
+         DO I = PA%I1,PA%I2
+            X_PTS(IFACT)=MESHES(NM)%X(I)
+            Y_PTS(IFACT)=MESHES(NM)%Y(J)
+            Z_PTS(IFACT)=MESHES(NM)%Z(PA%K1)
+            IFACT = IFACT + 1
+         ENDDO
+      ENDDO
+END SELECT
+
+! Fill cell data
+
+IFACT = 0
+DO I = 1, (L2-L1+1)
+   DO J = 1, (N2-N1+1)
+      CONNECT((IFACT)*4+1) = (L2-L1+2)*(J-1)+(I-1)
+      CONNECT((IFACT)*4+2) = (L2-L1+2)*(J-1)+(I)
+      CONNECT((IFACT)*4+3) = (L2-L1+2)*(J)+(I-1)
+      CONNECT((IFACT)*4+4) = (L2-L1+2)*(J)+(I)
+      IFACT = IFACT+1
+   ENDDO
+ENDDO
+
+DO I=1,NCELLS
+   OFFSETS(I) = (I)*4_IB32
+   VTKC_TYPE(I) = 8_IB8
+ENDDO
+         
+ENDSUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY
+
+
       
 SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
 
 REAL(FB), DIMENSION(:), ALLOCATABLE :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), DIMENSION(:), ALLOCATABLE :: CONNECT, OFFSETS
 INTEGER(IB8), DIMENSION(:), ALLOCATABLE :: VTKC_TYPE
-DEALLOCATE(OFFSETS)
+
 DEALLOCATE(VTKC_TYPE)
+DEALLOCATE(OFFSETS)
 DEALLOCATE(CONNECT)
 DEALLOCATE(X_PTS)
 DEALLOCATE(Y_PTS)

From 19aafcf561c13773a587c996f8c6ba815f3d956d Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 11:23:40 -0500
Subject: [PATCH 23/31] add GEOM boundary VTK output

---
 Source/dump.f90 | 110 +++++++++++++++++++++++++++++++++++++++++++++---
 Source/vtkf.f90 |  45 +++++++++++++++++++-
 2 files changed, 148 insertions(+), 7 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 2d4748899a8..3acb8aaf3d0 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -20,7 +20,7 @@ MODULE DUMP
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
 USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
-                WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
+                WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
 IMPLICIT NONE (TYPE,EXTERNAL)
@@ -1493,7 +1493,7 @@ SUBROUTINE WRITE_STL_FILE
          XB(:) = (/OB%X1,OB%X2,OB%Y1,OB%Y2,OB%Z1,OB%Z2/)
          !COLOR(:) = OB%SURF_INDEX(-1),OB%SURF_INDEX(1),OB%SURF_INDEX(-2),&
          !OB%SURF_INDEX(2),OB%SURF_INDEX(-3),OB%SURF_INDEX(3)
-         VERTICES = get_vertices(XB)
+         VERTICES = GET_VERTICES(XB)
          
          DO I=1,12
             !CALL write_facet_c(U, &
@@ -10750,19 +10750,20 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
 REAL(EB), INTENT(IN) :: T,DT
 REAL(FB) :: STIME, BOUND_MIN, BOUND_MAX, BF_FACTOR
 INTEGER :: ISUM,NF,IND,I,J,K,IC,IW,L,L1,L2,N,N1,N2,IP,NC,I1,I2,J1,J2,K1,K2,ITM,ITM1
-INTEGER :: NBF_DEBUG,IFACT
+INTEGER :: NBF_DEBUG,IFACT,NFACES_CUTCELLS,NVERTS_CUTCELLS,NVERTS,NFACES
 INTEGER, INTENT(IN) :: NM,IFRMT
 TYPE(PATCH_TYPE), POINTER :: PA
 REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
 INTEGER :: CHANGE_BOUND, IERROR
 INTEGER :: NX, NY, NZ, NCELLS, NPOINTS
+INTEGER, ALLOCATABLE, DIMENSION(:) :: LOCATIONS,FACES,SURFIND,GEOMIND
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
 TYPE(VTK_FILE)     :: A_VTK_FILE                    ! A VTK file.
 INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
-LOGICAL :: VTK_INITIALIZED
 
 IF (MESHES(NM)%N_PATCH==0 .AND. MESHES(NM)%N_INTERNAL_CFACE_CELLS==0) RETURN
 
@@ -10981,7 +10982,6 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
-      VTK_INITIALIZED=.TRUE.
       CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
       
       ! Loop through cell centered = F
@@ -11021,6 +11021,55 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE')
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
    ENDDO PATCH_LOOP1
+   
+   IF (CC_IBM) THEN
+      CALL POINT_TO_MESH(NM)
+      CALL GET_GEOMSIZES('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS)
+      IF (NVERTS>0 .AND. NFACES>0) THEN
+         ALLOCATE(VERTS(3*NVERTS))
+         ALLOCATE(FACES(3*NFACES))
+         ALLOCATE(LOCATIONS(NFACES))
+         ALLOCATE(SURFIND(NFACES))
+         ALLOCATE(GEOMIND(NFACES))
+         CALL GET_GEOMINFO('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS,&
+                           VERTS,FACES,LOCATIONS,SURFIND=SURFIND,GEOMIND=GEOMIND)
+         CALL BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+         DEALLOCATE(VERTS)
+         DEALLOCATE(FACES)
+         DEALLOCATE(LOCATIONS)
+         DEALLOCATE(SURFIND)
+         DEALLOCATE(GEOMIND)
+         
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NCELLS, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
+         
+         CALL DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
+         
+         ! Loop through cell centered = F
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN')
+         FILE_LOOPC: DO NF=1,N_BNDF
+            IF (BF%CELL_CENTERED) CYCLE FILE_LOOPC
+            BF => BOUNDARY_FILE(NF)
+            CALL PACK_VTK_GEOM(NM, BF%CELL_CENTERED, BF, VALS)
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=VALS)
+            DEALLOCATE(VALS)
+         ENDDO FILE_LOOPC
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE')
+         
+         ! Loop through cell centered = T
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='OPEN')
+         FILE_LOOPD: DO NF=1,N_BNDF
+            IF (.NOT.BF%CELL_CENTERED) CYCLE FILE_LOOPD
+            BF => BOUNDARY_FILE(NF)
+            CALL PACK_VTK_GEOM(NM, BF%CELL_CENTERED, BF, VALS)
+            VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=BF%SMOKEVIEW_LABEL(1:30), X=VALS)
+            DEALLOCATE(VALS)
+         ENDDO FILE_LOOPD
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='CELL', ACTION='CLOSE')
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+      ENDIF
+   ENDIF
    VTK_ERROR = A_VTK_FILE%FINALIZE()
 ENDIF
 
@@ -11131,7 +11180,56 @@ SUBROUTINE PACK_VTK_BNDF(PA,BF,IND,PP,PPN,QQ_PACK)
       ENDIF
 
    END SUBROUTINE PACK_VTK_BNDF
-
+   
+   SUBROUTINE PACK_VTK_GEOM(NM,CELL_CENTERED,BF,VALS)
+      INTEGER, INTENT(IN) :: NM
+      LOGICAL, INTENT(IN) :: CELL_CENTERED
+      TYPE(BOUNDARY_FILE_TYPE), POINTER, INTENT(IN) :: BF
+      REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS, VERT_VALS
+      INTEGER, ALLOCATABLE, DIMENSION(:) :: FACES, VERT_UNIQUE
+      INTEGER :: I, IND
+      INTEGER :: NPOINTS, NCELLS, NFACES, NVERTS, NVALS
+      
+      IND  = ABS(BF%INDEX)
+      CALL POINT_TO_MESH(NM)
+      CALL GET_GEOMSIZES('INBOUND_FACES',0,0,0,0,0,0,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS)
+      
+      IF (CELL_CENTERED) THEN
+         NVALS = NFACES
+         ALLOCATE(VALS(NFACES))
+         ! get values at geometry faces
+         CALL GET_GEOMVALS(CELL_CENTERED,CELL_CENTERED,'INBOUND_FACES',&
+                          I1,I2,J1,J2,K1,K2,NFACES,NFACES_CUTCELLS,VALS,&
+                          IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM)
+      ELSE
+         NVALS = NVERTS
+         ALLOCATE(VALS(MAX(NVERTS,NFACES)))
+
+         ! get values at geometry nodes
+         ALLOCATE(VERTS(3*NVERTS))
+         ALLOCATE(FACES(3*NFACES))
+         ALLOCATE(LOCATIONS(NFACES))
+         ALLOCATE(VERT_UNIQUE(NVERTS))
+         ALLOCATE(VERT_VALS(NVERTS))
+
+         CALL GET_GEOMVALS(CELL_CENTERED,CELL_CENTERED,'INBOUND_FACES',&
+                           I1,I2,J1,J2,K1,K2,NFACES,NFACES_CUTCELLS,VALS,&
+                           IND,0,BF%Y_INDEX,BF%Z_INDEX,BF%PART_INDEX,0,0,BF%PROP_INDEX,0,0,T,DT,NM)
+
+         ! these two routines need to be moved and called only once
+         CALL GET_GEOMINFO('INBOUND_FACES',I1,I2,J1,J2,K1,K2,NVERTS,NVERTS_CUTCELLS,NFACES,NFACES_CUTCELLS,VERTS,FACES,LOCATIONS)
+         CALL MAKE_UNIQUE_VERT_ARRAY(VERTS, VERT_UNIQUE, NVERTS)
+
+         CALL AVERAGE_FACE_VALUES(VERT_UNIQUE, VERT_VALS, NVERTS, FACES, VALS, NFACES)
+         VALS(1:NVERTS) = VERT_VALS(1:NVERTS)
+
+         DEALLOCATE(VERTS)
+         DEALLOCATE(FACES)
+         DEALLOCATE(LOCATIONS)
+         DEALLOCATE(VERT_UNIQUE)
+         DEALLOCATE(VERT_VALS)
+      ENDIF
+   END SUBROUTINE PACK_VTK_GEOM
 END SUBROUTINE DUMP_BNDF
 
 
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 73b3e802135..96b43fafcd6 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -18647,7 +18647,7 @@ MODULE VTK_FDS_INTERFACE
 
 PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
        WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,&
-       DEALLOCATE_VTK_GAS_PHASE_GEOMETRY
+       DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 
 CONTAINS
 
@@ -18975,6 +18975,49 @@ SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, &
 ENDSUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY
 
 
+SUBROUTINE BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS,&
+                                   X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+
+!INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2
+
+REAL(FB), ALLOCATABLE, DIMENSION(:), INTENT(IN) :: VERTS
+INTEGER, ALLOCATABLE, DIMENSION(:), INTENT(IN) :: FACES
+REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
+INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
+INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
+INTEGER :: I
+INTEGER :: NPOINTS, NCELLS, NFACES
+
+NPOINTS = SIZE(VERTS)/3
+NCELLS = SIZE(FACES)/3
+NFACES = SIZE(FACES)
+
+ALLOCATE(X_PTS(NPOINTS))
+ALLOCATE(Y_PTS(NPOINTS))
+ALLOCATE(Z_PTS(NPOINTS))
+ALLOCATE(CONNECT(NCELLS*3))
+ALLOCATE(OFFSETS(NCELLS))
+ALLOCATE(VTKC_TYPE(NCELLS))
+
+DO I=1,NPOINTS
+   X_PTS(I) = VERTS((I-1)*3+1)
+   Y_PTS(I) = VERTS((I-1)*3+2)
+   Z_PTS(I) = VERTS((I-1)*3)
+ENDDO
+
+DO I=1,NCELLS
+   OFFSETS(I) = (I)*3_IB32
+   VTKC_TYPE(I) = 5_IB8
+ENDDO
+
+DO I=1,NFACES
+   CONNECT(I) = FACES(I-1)
+ENDDO
+         
+ENDSUBROUTINE BUILD_VTK_GEOM_GEOMETRY
+
+
+
       
 SUBROUTINE DEALLOCATE_VTK_GAS_PHASE_GEOMETRY(X_PTS,Y_PTS,Z_PTS,OFFSETS,VTKC_TYPE,CONNECT)
 

From ab540e5d334b27a7ca6ff527036044712dd87820 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 13:14:14 -0500
Subject: [PATCH 24/31] fix connectivity in GEOM bndf vtk output

---
 Source/dump.f90 |  6 +++++-
 Source/vtkf.f90 | 56 +++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index 3acb8aaf3d0..dd25223d28a 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -20,7 +20,8 @@ MODULE DUMP
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
 USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
-                WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
+                WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
+				DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
 IMPLICIT NONE (TYPE,EXTERNAL)
@@ -160,6 +161,9 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ! VTK Boundary data
 
 IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN
+   IF (NM .EQ. 1) THEN
+      CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+   ENDIF
    CALL DUMP_BNDF(T,DT,NM,1)
    DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1)
       BNDF_VTK_COUNTER(NM) = BNDF_VTK_COUNTER(NM) + 1
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 96b43fafcd6..99d110d0493 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -18646,7 +18646,7 @@ MODULE VTK_FDS_INTERFACE
 PRIVATE
 
 PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
-       WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,&
+       WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
        DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 
 CONTAINS
@@ -18834,6 +18834,51 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
 
 
 
+SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+INTEGER, INTENT(IN) :: NMESHES
+CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
+REAL(EB), INTENT(IN) :: T
+TYPE(BOUNDARY_FILE_TYPE), POINTER :: BF
+INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
+REAL(FB) :: STIME
+REAL(EB) :: TT
+TYPE(PVTK_FILE)          :: A_PVTK_FILE       !< A parallel (partioned) VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+WRITE(FN_BNDF_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_BNDF_',ITM,ITM1,'.pvtu'
+VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_BNDF_VTK(NMESHES+1), MESH_TOPOLOGY='PUnstructuredGrid',&
+                                   MESH_KIND='Float32')
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN')
+! Add PointData arrays
+QUANTITY_LOOP2: DO IQ=1,N_BNDF
+   BF => BOUNDARY_FILE(IQ)
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(BF%SMOKEVIEW_LABEL(1:30)), &
+                                                           DATA_TYPE='Float32', NUMBER_OF_COMPONENTS=1)
+ENDDO QUANTITY_LOOP2
+VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE')
+
+DO I=1,NMESHES
+   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_BNDF_',I,'_',ITM,ITM1,'.vtu'
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE)
+ENDDO
+
+VTK_ERROR = A_PVTK_FILE%FINALIZE()
+END SUBROUTINE WRITE_VTK_BNDF_WRAPPER
+
+
+
+
+
 SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, &
                                         NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
 
@@ -19002,16 +19047,15 @@ SUBROUTINE BUILD_VTK_GEOM_GEOMETRY(VERTS, FACES, NCELLS, NPOINTS,&
 DO I=1,NPOINTS
    X_PTS(I) = VERTS((I-1)*3+1)
    Y_PTS(I) = VERTS((I-1)*3+2)
-   Z_PTS(I) = VERTS((I-1)*3)
+   Z_PTS(I) = VERTS((I-1)*3+3)
 ENDDO
 
 DO I=1,NCELLS
    OFFSETS(I) = (I)*3_IB32
    VTKC_TYPE(I) = 5_IB8
-ENDDO
-
-DO I=1,NFACES
-   CONNECT(I) = FACES(I-1)
+   CONNECT(3*(I-1)+1) = FACES(3*(I-1)+1)-1
+   CONNECT(3*(I-1)+2) = FACES(3*(I-1)+2)-1
+   CONNECT(3*(I-1)+3) = FACES(3*(I-1)+3)-1
 ENDDO
          
 ENDSUBROUTINE BUILD_VTK_GEOM_GEOMETRY

From 131f3f55c5afd0f1634fd58d9b03ed5a0ec1b708 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 13:41:36 -0500
Subject: [PATCH 25/31] start adding particle vtk output

---
 Source/cons.f90 |  7 ++++---
 Source/dump.f90 | 13 +++++++++++++
 Source/func.f90 |  1 +
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 146726680db..f67c27be93f 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -549,7 +549,7 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, &
                                               FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF
-CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK
+CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK,FN_PART_VTK
 
 CHARACTER(9) :: FMT_R
 LOGICAL :: OUT_FILE_OPENED=.FALSE.
@@ -763,14 +763,15 @@ MODULE OUTPUT_CLOCKS
 INTEGER :: RAMP_SL3D_VTK_INDEX=0   !< Ramp index for vtk file time series
 INTEGER :: RAMP_SM3D_VTK_INDEX=0   !< Ramp index for vtk file time series
 INTEGER :: RAMP_BNDF_VTK_INDEX=0   !< Ramp index for boundary file time series
+INTEGER :: RAMP_PART_VTK_INDEX=0   !< Ramp index for boundary file time series
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: BNDF_CLOCK, CPU_CLOCK,CTRL_CLOCK,DEVC_CLOCK,FLSH_CLOCK,GEOM_CLOCK, HRR_CLOCK,HVAC_CLOCK,&
                                        ISOF_CLOCK,MASS_CLOCK,PART_CLOCK,PL3D_CLOCK,PROF_CLOCK,RADF_CLOCK,RSRT_CLOCK,&
                                        SLCF_CLOCK,SL3D_CLOCK,SM3D_CLOCK,UVW_CLOCK ,TMP_CLOCK ,SPEC_CLOCK,&
-                                       SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK
+                                       SL3D_VTK_CLOCK,SM3D_VTK_CLOCK,BNDF_VTK_CLOCK,PART_VTK_CLOCK
 INTEGER, ALLOCATABLE, DIMENSION(:) :: BNDF_COUNTER, CPU_COUNTER,CTRL_COUNTER,DEVC_COUNTER,FLSH_COUNTER,GEOM_COUNTER, HRR_COUNTER,&
                                       HVAC_COUNTER,ISOF_COUNTER,MASS_COUNTER,PART_COUNTER,PL3D_COUNTER,PROF_COUNTER,RADF_COUNTER,&
                                       RSRT_COUNTER,SLCF_COUNTER,SL3D_COUNTER,SM3D_COUNTER,UVW_COUNTER ,TMP_COUNTER ,SPEC_COUNTER,&
-                                      SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER
+                                      SL3D_VTK_COUNTER,SM3D_VTK_COUNTER,BNDF_VTK_COUNTER,PART_VTK_COUNTER
 REAL(EB) :: TURB_INIT_CLOCK=-1.E10_EB
 REAL(EB) :: MMS_TIMER=1.E10_EB
 REAL(EB) :: DT_SLCF,DT_BNDF,DT_DEVC,DT_PL3D,DT_PART,DT_RESTART,DT_ISOF,DT_HRR,DT_HVAC,DT_MASS,DT_PROF,DT_CTRL,&
diff --git a/Source/dump.f90 b/Source/dump.f90
index dd25223d28a..e54ebd78010 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -171,6 +171,18 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
    ENDDO
 ENDIF
 
+! VTK Particle data
+IF (T>=PART_VTK_CLOCK(PART_VTK_COUNTER(NM)) .AND. PARTICLE_FILE) THEN
+   IF (NM .EQ. 1) THEN
+      !CALL WRITE_VTK_PART_WRAPPER(T,NMESHES,'PPolyData')
+   ENDIF
+   !CALL DUMP_PART(T,NM)
+   DO WHILE(PART_VTK_COUNTER(NM)<SIZE(PART_VTK_CLOCK)-1)
+      PART_VTK_COUNTER(NM) = PART_VTK_COUNTER(NM) + 1
+      IF (PART_VTK_CLOCK(PART_VTK_COUNTER(NM))>=T) EXIT
+   ENDDO
+ENDIF
+
 IF (T>=BNDF_CLOCK(BNDF_COUNTER(NM))) THEN
    CALL DUMP_BNDF(T,DT,NM,0)
    DO WHILE(BNDF_COUNTER(NM)<SIZE(BNDF_CLOCK)-1)
@@ -410,6 +422,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1))
 ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1))
 ALLOCATE(FN_BNDF_VTK(NMESHES+1))
+ALLOCATE(FN_PART_VTK(NMESHES+1))
 
 MESH_LOOP: DO NM=1,NMESHES
 
diff --git a/Source/func.f90 b/Source/func.f90
index 6697bfd5a78..ed2a96e515c 100644
--- a/Source/func.f90
+++ b/Source/func.f90
@@ -484,6 +484,7 @@ SUBROUTINE INITIALIZE_OUTPUT_CLOCKS(T)
 CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SL3D_VTK_INDEX,  SL3D_VTK_CLOCK, SL3D_VTK_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_SM3D_VTK_INDEX,  SM3D_VTK_CLOCK, SM3D_VTK_COUNTER,.TRUE. ,.TRUE. )
 CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_BNDF_VTK_INDEX,  BNDF_VTK_CLOCK, BNDF_VTK_COUNTER,.TRUE. ,.TRUE. )
+CALL SET_OUTPUT_CLOCK(DT_VTK    ,RAMP_PART_VTK_INDEX,  PART_VTK_CLOCK, PART_VTK_COUNTER,.TRUE. ,.TRUE. )
 
 ! Special cases
 

From 841423604384928fb1aaa9c3756e3e3011ad1ce0 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 13:42:03 -0500
Subject: [PATCH 26/31] Start adding PPOLYDATA type

---
 Source/vtkf.f90 | 175 +++++++++++++++++++++++++++++-------------------
 1 file changed, 106 insertions(+), 69 deletions(-)

diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 99d110d0493..98e01719cac 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -3856,10 +3856,10 @@ MODULE STRINGIFOR_STRING_T
     PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_CHARACTER !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
     PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_STRINGS     !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
     PROCEDURE, PRIVATE, PASS(SELF) :: JOIN_CHARACTERS  !< RETURN JOIN STRING OF AN ARRAY OF CHARACTERS.
-    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_STRINGS  !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
-    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_CHARACTERS        !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
-    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_STRINGS_ARRAY     !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN COLUMNS OR ROWS.
-    PROCEDURE, PRIVATE, NOPASS ::     STRJOIN_CHARACTERS_ARRAY  !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN COLUMNS OR ROWS.
+    PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS  !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
+    PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS        !< RETURN JOIN STRING OF AN ARRAY OF STRINGS.
+    PROCEDURE, PRIVATE, NOPASS :: STRJOIN_STRINGS_ARRAY     !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF STRINGS IN C OR R.
+    PROCEDURE, PRIVATE, NOPASS :: STRJOIN_CHARACTERS_ARRAY  !< RETURN JOIN 1D STRING ARRAY OF AN 2D ARRAY OF CHARACTERS IN C OR R.
     PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I1P   !< CAST STRING TO INTEGER.
 #ifndef _NVF
     PROCEDURE, PRIVATE, PASS(SELF) :: TO_INTEGER_I2P   !< CAST STRING TO INTEGER.
@@ -4126,7 +4126,7 @@ ELEMENTAL FUNCTION SINDEX_CHARACTER_STRING(S, SUBSTRING, BACK) RESULT(I)
    ENDFUNCTION SINDEX_CHARACTER_STRING
 
    ELEMENTAL FUNCTION SSCAN_CHARACTER_STRING(S, SET, BACK) RESULT(I)
-   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET.
    !<
    !<```FORTRAN
    !< TYPE(STRING) :: STRING1
@@ -4215,8 +4215,8 @@ ELEMENTAL FUNCTION SCOUNT(SELF, SUBSTRING, IGNORE_ISOLATED) RESULT(NO)
    !< COUNT THE NUMBER OF OCCURENCES OF A SUBSTRING INTO A STRING.
    !<
    !< @NOTE IF `IGNORE_ISOLATED` IS SET TO TRUE THE EVENTUAL "ISOLATED" OCCURENCES ARE IGNORED: AN ISOLATED OCCURRENCES ARE THOSE
-   !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING A
-   !< RIGHT COMPANION).
+   !< OCCURRENCES HAPPENING AT THE START OF STRING (THUS NOT HAVING A LEFT COMPANION) OR AT THE END OF THE STRING (THUS NOT HAVING
+   !< A RIGHT COMPANION).
    !<
    !<```FORTRAN
    !< TYPE(STRING) :: ASTRING
@@ -4299,7 +4299,7 @@ ELEMENTAL FUNCTION SINDEX_STRING_CHARACTER(SELF, SUBSTRING, BACK) RESULT(I)
    !< LOGICAL      :: TEST_PASSED(2)
    !< STRING1 = 'HELLO WORLD HELLO!'
    !< TEST_PASSED(1) = STRING1%INDEX(SUBSTRING='LLO')==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO')
-   !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO', BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.)
+   !< TEST_PASSED(2) = STRING1%INDEX(SUBSTRING='LLO',BACK=.TRUE.)==INDEX(STRING='HELLO WORLD HELLO!', SUBSTRING='LLO', BACK=.TRUE.)
    !< PRINT '(L1)', ALL(TEST_PASSED)
    !<```
    !=> T <<<
@@ -4394,7 +4394,7 @@ ELEMENTAL FUNCTION SREPEAT_CHARACTER_STRING(RSTRING, NCOPIES) RESULT(REPEATED)
    ENDFUNCTION SREPEAT_CHARACTER_STRING
 
    ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I)
-   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET.
    !<
    !<```FORTRAN
    !< TYPE(STRING) :: STRING1
@@ -4420,7 +4420,7 @@ ELEMENTAL FUNCTION SSCAN_STRING_STRING(SELF, SET, BACK) RESULT(I)
    ENDFUNCTION SSCAN_STRING_STRING
 
    ELEMENTAL FUNCTION SSCAN_STRING_CHARACTER(SELF, SET, BACK) RESULT(I)
-   !< RETURN THE LEFTMOST (IF `BACK` IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN `SET`.
+   !< RETURN THE LEFTMOST (IF BACK IS EITHER ABSENT OR EQUALS FALSE, OTHERWISE THE RIGHTMOST) CHARACTER OF STRING THAT IS IN SET.
    !<
    !<```FORTRAN
    !< TYPE(STRING) :: STRING1
@@ -4821,7 +4821,8 @@ ELEMENTAL SUBROUTINE FREE(SELF)
    ENDSUBROUTINE FREE
 
    SUBROUTINE GLOB_CHARACTER(SELF, PATTERN, LIST)
-   !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX SHELL.
+   !< GLOB SEARCH (CHARACTER OUTPUT), FINDS ALL THE PATHNAMES MATCHING A GIVEN PATTERN ACCORDING TO THE RULES USED BY THE UNIX
+   !< SHELL.
    !<
    !< @NOTE METHOD NOT PORTABLE: WORKS ONLY ON UNIX/GNU LINUX OS.
    !<
@@ -5172,55 +5173,6 @@ PURE FUNCTION STRJOIN_CHARACTERS(ARRAY, SEP, IS_TRIM) RESULT(JOIN)
    !< THE JOIN-SEPARATOR IS SET EQUALS TO A NULL STRING '' IF CUSTOM SEPARATOR ISN'T SPECIFIED.
    !< THE TRIM FUNCTION IS APPLIED TO ARRAY ITEMS IF OPTIONAL LOGICAL IS_TRIM VARIABLE ISN'T SET TO .FALSE.
    !<
-   !<```FORTRAN
-   !< CHARACTER(5) :: CHARACTERS(3)
-   !< LOGICAL      :: TEST_PASSED(13)
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(1) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3)))
-   !< TEST_PASSED(2) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3)))
-   !< TEST_PASSED(3) = ( STRJOIN(ARRAY=CHARACTERS, IS_TRIM=.FALSE.)//''==CHARACTERS(1)//CHARACTERS(2)//CHARACTERS(3))
-   !< TEST_PASSED(4) = ( STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2)//'-'//CHARACTERS(3))
-   !< CHARACTERS(1) = ''
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(5) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(2))//TRIM(CHARACTERS(3)))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = ''
-   !< TEST_PASSED(6) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(2)))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = ''
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(7) = (STRJOIN(ARRAY=CHARACTERS)//''==TRIM(CHARACTERS(1))//TRIM(CHARACTERS(3)))
-   !< CHARACTERS(1) = ''
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(8) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(2))//'-'//TRIM(CHARACTERS(3)))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = ''
-   !< TEST_PASSED(9) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(2)))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = ''
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(10) = (STRJOIN(ARRAY=CHARACTERS, SEP='-')//''==TRIM(CHARACTERS(1))//'-'//TRIM(CHARACTERS(3)))
-   !< CHARACTERS(1) = ''
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(11) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(2)//'-'//CHARACTERS(3))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = 'TWO'
-   !< CHARACTERS(3) = ''
-   !< TEST_PASSED(12) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(2))
-   !< CHARACTERS(1) = 'ONE'
-   !< CHARACTERS(2) = ''
-   !< CHARACTERS(3) = 'THREE'
-   !< TEST_PASSED(13) = (STRJOIN(ARRAY=CHARACTERS, SEP='-', IS_TRIM=.FALSE.)//''==CHARACTERS(1)//'-'//CHARACTERS(3))
-   !< PRINT '(L1)', ALL(TEST_PASSED)
-   !<```
-   !=> T <<<
    CHARACTER(KIND=CK, LEN=*), INTENT(IN)           :: ARRAY(1:) !< ARRAY TO BE JOINED.
    CHARACTER(KIND=CK, LEN=*), INTENT(IN), OPTIONAL :: SEP       !< SEPARATOR.
    LOGICAL,                   INTENT(IN), OPTIONAL :: IS_TRIM   !< FLAG TO SETUP TRIM CHARACTER OR NOT
@@ -5301,7 +5253,7 @@ PURE FUNCTION STRJOIN_STRINGS_ARRAY(ARRAY, SEP, IS_COL) RESULT(JOIN)
    TYPE(STRING),              ALLOCATABLE          :: SLICE(:)      !< THE COLUMN OR ROW SLICE OF ARRAY
    CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_          !< SEPARATOR, DEFAULT VALUE.
    LOGICAL                                         :: IS_COL_       !< DIRECTION, DEFAULT VALUE.
-   INTEGER                                         :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
+   INTEGER                                      :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
 
    SEP_    = ''     ; IF (PRESENT(SEP)) SEP_ = SEP
    IS_COL_ = .TRUE. ; IF (PRESENT(IS_COL)) IS_COL_ = IS_COL
@@ -5399,8 +5351,8 @@ PURE FUNCTION STRJOIN_CHARACTERS_ARRAY(ARRAY, SEP, IS_TRIM, IS_COL) RESULT(JOIN)
    CHARACTER(KIND=CK, LEN=:), ALLOCATABLE          :: SEP_      !< SEPARATOR, DEFAULT VALUE.
    LOGICAL                                         :: IS_TRIM_  !< FLAG TO SETUP TRIM CHARACTER OR NOT
    LOGICAL                                         :: IS_COL_   !< DIRECTION, DEFAULT VALUE.
-   INTEGER                                         :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
-   INTEGER                                         :: ITEM_LEN  !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS)
+   INTEGER                                      :: A, JOIN_SIZE, SLICE_SIZE  !< COUNTER, SIZES OF JOIN VECTOR AND OF SLICE OF ARRAY
+   INTEGER                                   :: ITEM_LEN  !< LENGTH OF ARRAY ITEM (ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS)
 
    ITEM_LEN = LEN(ARRAY(1,1)) !< ALL ITEMS OF CHARACTER ARRAY HAVE EQUAL LENGTHS
    SEP_     = ''     ; IF (PRESENT(SEP)) SEP_ = SEP
@@ -6626,7 +6578,8 @@ SUBROUTINE WRITE_FILE(SELF, FILE, FORM, IOSTAT, IOMSG)
    SUBROUTINE WRITE_LINE(SELF, UNIT, FORM, IOSTAT, IOMSG)
    !< WRITE LINE (RECORD) TO A CONNECTED UNIT.
    !<
-   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE.
+   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF
+   !< LINE.
    !<
    !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS.
    CLASS(STRING),    INTENT(IN)              :: SELF    !< THE STRING.
@@ -6662,7 +6615,8 @@ SUBROUTINE WRITE_LINES(SELF, UNIT, FORM, IOSTAT, IOMSG)
    !<
    !< THIS METHOD CHECKS IF SELF CONTAINS MORE THAN ONE LINE (RECORDS) AND WRITES THEM AS LINES (RECORDS).
    !<
-   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF LINE.
+   !< @NOTE IF THE CONNECTED UNIT IS UNFORMATTED A `NEW_LINE()` CHARACTER IS ADDED AT THE END (IF NECESSARY) TO MARK THE END OF
+   !< LINE.
    !<
    !< @NOTE THERE IS NO DOCTESTS, THIS BEING TESTED BY MEANS OF [[STRING:WRITE_FILE]] DOCTESTS.
    CLASS(STRING),    INTENT(IN)              :: SELF     !< THE STRING.
@@ -9721,6 +9675,10 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R8P    !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R4P    !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R4P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R8P    !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R8P).
+    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R4P    !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG             !< WRITE `<PIECE ...>` START TAG.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG_UNST        !< WRITE `<PIECE ...>` START TAG FOR UNSTRUCTURED TOPOLOGY.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_END_TAG               !< WRITE `</PIECE>` END TAG.
@@ -10503,7 +10461,7 @@ SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND)
                TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '//&
                TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '//&
                TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" GhostLevel="#"'
-   CASE('PUnstructuredGrid')
+   CASE('PUnstructuredGrid','PPolyData')
       BUFFER = 'GhostLevel="0"'
    ENDSELECT
    CALL SELF%WRITE_START_TAG(NAME=SELF%TOPOLOGY%CHARS(), ATTRIBUTES=BUFFER%CHARS())
@@ -10519,7 +10477,7 @@ SUBROUTINE WRITE_TOPOLOGY_TAG(SELF, NX1, NX2, NY1, NY2, NZ1, NZ2, MESH_KIND)
       CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"')
       CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='PDataArray', ATTRIBUTES='type="'//TRIM(MESH_KIND)//'"')
       CALL SELF%WRITE_END_TAG(NAME='PCoordinates')
-   CASE('PStructuredGrid', 'PUnstructuredGrid')
+   CASE('PStructuredGrid', 'PUnstructuredGrid','PPolyData')
       IF (.NOT.PRESENT(MESH_KIND)) THEN
          SELF%ERROR = 1
          RETURN
@@ -10633,7 +10591,7 @@ FUNCTION W_DATA_LOCATION_TAG(SELF, LOCATION, ACTION) RESULT(ERROR)
       LOCATION_ = 'PointData'
    ENDSELECT
    SELECT CASE(SELF%TOPOLOGY%CHARS())
-   CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid')
+   CASE('PRectilinearGrid', 'PStructuredGrid', 'PUnstructuredGrid','PPolyData')
       LOCATION_ = 'P'//LOCATION_
    ENDSELECT
    SELECT CASE(ACTION_%CHARS())
@@ -10968,6 +10926,83 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
    ERROR = SELF%ERROR
    ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P
 
+   ! WRITE_GEO_POLY METHODS
+   FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
+   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   IF (NP/=SIZE(XYZ, DIM=2)) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P
+
+   FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR)
+   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
+   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
+   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
+
+   IF (NP/=SIZE(XYZ, DIM=2)) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P
+
+   FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP    !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC    !< NUMBER OF CELLS.
+   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P
+
+   FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R4P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: NP    !< NUMBER OF POINTS.
+   INTEGER(I4P),               INTENT(IN)    :: NC    !< NUMBER OF CELLS.
+   REAL(R4P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R4P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+
+   IF ((NP/=SIZE(X, DIM=1)).OR.(NP/=SIZE(Y, DIM=1)).OR.(NP/=SIZE(Z, DIM=1))) THEN
+      SELF%ERROR = 1
+      RETURN
+   ENDIF
+   CALL SELF%WRITE_START_TAG(NAME='Points')
+   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
+   CALL SELF%WRITE_END_TAG(NAME='Points')
+   ERROR = SELF%ERROR
+   ENDFUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P
+
    FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FACEOFFSET) RESULT(ERROR)
    !< WRITE MESH CONNECTIVITY.
    !<
@@ -11109,7 +11144,7 @@ FUNCTION WRITE_PARALLEL_GEO(SELF, SOURCE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(E
                TRIM(STR(N=NX1))//' '//TRIM(STR(N=NX2))//' '// &
                TRIM(STR(N=NY1))//' '//TRIM(STR(N=NY2))//' '// &
                TRIM(STR(N=NZ1))//' '//TRIM(STR(N=NZ2))//'" Source="'//TRIM(ADJUSTL(SOURCE))//'"'
-   CASE('PUnstructuredGrid')
+   CASE('PUnstructuredGrid','PPolyData')
       BUFFER = 'Source="'//TRIM(ADJUSTL(SOURCE))//'"'
    ENDSELECT
    CALL SELF%WRITE_SELF_CLOSING_TAG(NAME='Piece', ATTRIBUTES=BUFFER%CHARS())
@@ -18424,6 +18459,7 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2
    !<- RECTILINEARGRID;
    !<- STRUCTUREDGRID;
    !<- UNSTRUCTUREDGRID.
+   !<- POLYDATA
    !<
    !<### EXAMPLE OF USAGE
    !<
@@ -18522,6 +18558,7 @@ FUNCTION INITIALIZE(SELF, FILENAME, MESH_TOPOLOGY, MESH_KIND, NX1, NX2, NY1, NY2
   !<- PRECTILINEARGRID;
   !<- PSTRUCTUREDGRID;
   !<- PUNSTRUCTUREDGRID.
+  !<- PPOLYDATA
   !<
   !<### EXAMPLE OF USAGE
   !<

From 84571391626b1fc2ea9639f770e164bb85f2d59f Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 15:05:44 -0500
Subject: [PATCH 27/31] Remove unused routines from vtkf

---
 Source/dump.f90 |    2 +-
 Source/vtkf.f90 | 7095 +++--------------------------------------------
 2 files changed, 378 insertions(+), 6719 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index e54ebd78010..0aed6f61b17 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -19,7 +19,7 @@ MODULE DUMP
                              CC_VGSC,CC_GASPHASE,MAKE_UNIQUE_VERT_ARRAY,AVERAGE_FACE_VALUES
 
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
-USE VTK_FDS_INTERFACE, ONLY : WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
+USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
                 WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
 				DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 98e01719cac..74db6a9bdc6 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -3390,295 +3390,6 @@ PURE SUBROUTINE B64_DECODE_STRING_A(CODE, S)
 
 
 
-!< FACE, FORTRAN ANSI COLORS ENVIRONMENT.
-MODULE FACE
-!< FACE, FORTRAN ANSI COLORS ENVIRONMENT.
-USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY: INT32
-
-IMPLICIT NONE
-PRIVATE
-PUBLIC :: COLORIZE
-PUBLIC :: COLORS_SAMPLES
-PUBLIC :: STYLES_SAMPLES
-PUBLIC :: ASCII
-PUBLIC :: UCS4
-
-INTERFACE COLORIZE
-#if defined ASCII_SUPPORTED && defined ASCII_NEQ_DEFAULT
-   MODULE PROCEDURE COLORIZE_ASCII
-   MODULE PROCEDURE COLORIZE_DEFAULT
-#else
-   MODULE PROCEDURE COLORIZE_DEFAULT
-#endif
-#ifdef UCS4_SUPPORTED
-   MODULE PROCEDURE COLORIZE_UCS4
-#endif
-ENDINTERFACE
-
-! KIND PARAMETERS
-#ifdef ASCII_SUPPORTED
-INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('ASCII')     !< ASCII CHARACTER SET KIND.
-#else
-INTEGER, PARAMETER :: ASCII = SELECTED_CHAR_KIND('DEFAULT')   !< ASCII CHARACTER SET KIND.
-#endif
-#ifdef UCS4_SUPPORTED
-INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('ISO_10646') !< UNICODE CHARACTER SET KIND.
-#else
-INTEGER, PARAMETER :: UCS4  = SELECTED_CHAR_KIND('DEFAULT')   !< UNICODE CHARACTER SET KIND.
-#endif
-! PARAMETERS
-CHARACTER(26), PARAMETER :: UPPER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< UPPER CASE ALPHABET.
-CHARACTER(26), PARAMETER :: LOWER_ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ' !< LOWER CASE ALPHABET.
-CHARACTER(1),  PARAMETER :: NL=NEW_LINE('A')                            !< NEW LINE CHARACTER.
-CHARACTER(1),  PARAMETER :: ESCAPE=ACHAR(27)                            !< "\" CHARACTER.
-! CODES
-CHARACTER(2), PARAMETER :: CODE_START=ESCAPE//'['               !< START ANSI CODE, "\[".
-CHARACTER(1), PARAMETER :: CODE_END='M'                         !< END ANSI CODE, "M".
-CHARACTER(4), PARAMETER :: CODE_CLEAR=CODE_START//'0'//CODE_END !< CLEAR ALL STYLES, "\[0M".
-! STYLES CODES
-CHARACTER(17), PARAMETER :: STYLES(1:2,1:16)=RESHAPE([&
-             'BOLD_ON          ','1                ', &         !  BOLD ON.
-             'ITALICS_ON       ','3                ', &         !  ITALICS ON.
-             'UNDERLINE_ON     ','4                ', &         !  UNDERLINE ON.
-             'INVERSE_ON       ','7                ', &         !  INVERSE ON: REVERSE FOREGROUND AND BACKGROUND COLORS.
-             'STRIKETHROUGH_ON ','9                ', &         !  STRIKETHROUGH ON.
-             'BOLD_OFF         ','22               ', &         !  BOLD OFF.
-             'ITALICS_OFF      ','23               ', &         !  ITALICS OFF.
-             'UNDERLINE_OFF    ','24               ', &         !  UNDERLINE OFF.
-             'INVERSE_OFF      ','27               ', &         !  INVERSE OFF: REVERSE FOREGROUND AND BACKGROUND COLORS.
-             'STRIKETHROUGH_OFF','29               ', &         !  STRIKETHROUGH OFF.
-             'FRAMED_ON        ','51               ', &         !  FRAMED ON.
-             'ENCIRCLED_ON     ','52               ', &         !  ENCIRCLED ON.
-             'OVERLINED_ON     ','53               ', &         !  OVERLINED ON.
-             'FRAMED_OFF       ','54               ', &         !  FRAMED OFF.
-             'ENCIRCLED_OFF    ','54               ', &         !  ENCIRCLED OFF.
-             'OVERLINED_OFF    ','55               '  &         !  OVERLINED OFF.
-                                                     ], [2,16]) !< STYLES.
-! COLORS CODES
-CHARACTER(15), PARAMETER :: COLORS_FG(1:2,1:17)=RESHAPE([&
-                    'BLACK          ','30             ', &         !  BLACK.
-                    'RED            ','31             ', &         !  RED.
-                    'GREEN          ','32             ', &         !  GREEN.
-                    'YELLOW         ','33             ', &         !  YELLOW.
-                    'BLUE           ','34             ', &         !  BLUE.
-                    'MAGENTA        ','35             ', &         !  MAGENTA.
-                    'CYAN           ','36             ', &         !  CYAN.
-                    'WHITE          ','37             ', &         !  WHITE.
-                    'DEFAULT        ','39             ', &         !  DEFAULT (WHITE).
-                    'BLACK_INTENSE  ','90             ', &         !  BLACK INTENSE.
-                    'RED_INTENSE    ','91             ', &         !  RED INTENSE.
-                    'GREEN_INTENSE  ','92             ', &         !  GREEN INTENSE.
-                    'YELLOW_INTENSE ','93             ', &         !  YELLOW INTENSE.
-                    'BLUE_INTENSE   ','94             ', &         !  BLUE INTENSE.
-                    'MAGENTA_INTENSE','95             ', &         !  MAGENTA INTENSE.
-                    'CYAN_INTENSE   ','96             ', &         !  CYAN INTENSE.
-                    'WHITE_INTENSE  ','97             '  &         !  WHITE INTENSE.
-                                                        ], [2,17]) !< FOREGROUND COLORS.
-CHARACTER(15), PARAMETER :: COLORS_BG(1:2,1:17)=RESHAPE([&
-                    'BLACK          ','40             ', &         !  BLACK.
-                    'RED            ','41             ', &         !  RED.
-                    'GREEN          ','42             ', &         !  GREEN.
-                    'YELLOW         ','43             ', &         !  YELLOW.
-                    'BLUE           ','44             ', &         !  BLUE.
-                    'MAGENTA        ','45             ', &         !  MAGENTA.
-                    'CYAN           ','46             ', &         !  CYAN.
-                    'WHITE          ','47             ', &         !  WHITE.
-                    'DEFAULT        ','49             ', &         !  DEFAULT (BLACK).
-                    'BLACK_INTENSE  ','100            ', &         !  BLACK INTENSE.
-                    'RED_INTENSE    ','101            ', &         !  RED INTENSE.
-                    'GREEN_INTENSE  ','102            ', &         !  GREEN INTENSE.
-                    'YELLOW_INTENSE ','103            ', &         !  YELLOW INTENSE.
-                    'BLUE_INTENSE   ','104            ', &         !  BLUE INTENSE.
-                    'MAGENTA_INTENSE','105            ', &         !  MAGENTA INTENSE.
-                    'CYAN_INTENSE   ','106            ', &         !  CYAN INTENSE.
-                    'WHITE_INTENSE  ','107            '  &         !  WHITE INTENSE.
-                                                        ], [2,17]) !< BACKGROUND COLORS.
-CONTAINS
-   ! PUBLIC PROCEDURES
-   SUBROUTINE COLORS_SAMPLES()
-   !< PRINT TO STANDARD OUTPUT ALL COLORS SAMPLES.
-   INTEGER(INT32) :: C !< COUNTER.
-
-   PRINT '(A)', COLORIZE('FOREGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE')
-   DO C=1, SIZE(COLORS_FG, DIM=2)
-      PRINT '(A)', '  COLORIZE("'//COLORS_FG(1, C)//'", COLOR_FG="'//COLORS_FG(1, C)//'") => '//&
-         COLORIZE(COLORS_FG(1, C), COLOR_FG=COLORS_FG(1, C))//&
-         ' CODE: '//COLORIZE(TRIM(COLORS_FG(2, C)), COLOR_FG=COLORS_FG(1, C), STYLE='INVERSE_ON')
-   ENDDO
-   PRINT '(A)', COLORIZE('BACKGROUND COLORS SAMPLES', COLOR_FG='RED_INTENSE')
-   DO C=1, SIZE(COLORS_BG, DIM=2)
-      PRINT '(A)', '  COLORIZE("'//COLORS_BG(1, C)//'", COLOR_BG="'//COLORS_BG(1, C)//'") => '//&
-         COLORIZE(COLORS_BG(1, C), COLOR_BG=COLORS_BG(1, C))//&
-         ' CODE: '//COLORIZE(TRIM(COLORS_BG(2, C)), COLOR_BG=COLORS_BG(1, C), STYLE='INVERSE_ON')
-   ENDDO
-   ENDSUBROUTINE COLORS_SAMPLES
-
-   SUBROUTINE STYLES_SAMPLES()
-   !< PRINT TO STANDARD OUTPUT ALL STYLES SAMPLES.
-   INTEGER(INT32) :: S !< COUNTER.
-
-   PRINT '(A)', COLORIZE('STYLES SAMPLES', COLOR_FG='RED_INTENSE')
-   DO S=1, SIZE(STYLES, DIM=2)
-      PRINT '(A)', '  COLORIZE("'//STYLES(1, S)//'", STYLE="'//STYLES(1, S)//'") => '//&
-         COLORIZE(STYLES(1, S), STYLE=STYLES(1, S))//&
-         ' CODE: '//COLORIZE(TRIM(STYLES(2, S)), COLOR_FG='MAGENTA', STYLE='INVERSE_ON')
-   ENDDO
-   ENDSUBROUTINE STYLES_SAMPLES
-
-   ! PRIVATE PROCEDURES
-   PURE FUNCTION COLORIZE_ASCII(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
-   !< COLORIZE AND STYLIZE STRINGS, ASCII KIND.
-   CHARACTER(LEN=*, KIND=ASCII), INTENT(IN)           :: STRING    !< INPUT STRING.
-   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*),             INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
-   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
-   CHARACTER(LEN=:, KIND=ASCII), ALLOCATABLE          :: BUFFER    !< TEMPORARY BUFFER.
-   INTEGER(INT32)                                     :: I         !< COUNTER.
-
-   COLORIZED = STRING
-   IF (PRESENT(COLOR_FG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_FG))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   IF (PRESENT(COLOR_BG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_BG))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   IF (PRESENT(STYLE)) THEN
-      I = STYLE_INDEX(UPPER(STYLE))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   ENDFUNCTION COLORIZE_ASCII
-
-   PURE FUNCTION COLORIZE_DEFAULT(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
-   !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND.
-   CHARACTER(LEN=*), INTENT(IN)           :: STRING    !< INPUT STRING.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
-   CHARACTER(LEN=:), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
-   INTEGER(INT32)                         :: I         !< COUNTER.
-
-   COLORIZED = STRING
-   IF (PRESENT(COLOR_FG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_FG))
-      IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END//COLORIZED//CODE_CLEAR
-   ENDIF
-   IF (PRESENT(COLOR_BG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_BG))
-      IF (I>0) COLORIZED = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END//COLORIZED//CODE_CLEAR
-   ENDIF
-   IF (PRESENT(STYLE)) THEN
-      I = STYLE_INDEX(UPPER(STYLE))
-      IF (I>0) COLORIZED = CODE_START//TRIM(STYLES(2, I))//CODE_END//COLORIZED//CODE_CLEAR
-   ENDIF
-   ENDFUNCTION COLORIZE_DEFAULT
-
-   PURE FUNCTION COLORIZE_UCS4(STRING, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
-   !< COLORIZE AND STYLIZE STRINGS, UCS4 KIND.
-   CHARACTER(LEN=*, KIND=UCS4), INTENT(IN)           :: STRING    !< INPUT STRING.
-   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*),            INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
-   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
-   CHARACTER(LEN=:, KIND=UCS4), ALLOCATABLE          :: BUFFER    !< TEMPORARY BUFFER.
-   INTEGER(INT32)                                    :: I         !< COUNTER.
-
-   COLORIZED = STRING
-   IF (PRESENT(COLOR_FG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_FG))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(COLORS_FG(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   IF (PRESENT(COLOR_BG)) THEN
-      I = COLOR_INDEX(UPPER(COLOR_BG))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(COLORS_BG(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   IF (PRESENT(STYLE)) THEN
-      I = STYLE_INDEX(UPPER(STYLE))
-      IF (I>0) THEN
-         BUFFER = CODE_START//TRIM(STYLES(2, I))//CODE_END
-         COLORIZED = BUFFER//COLORIZED
-         BUFFER = CODE_CLEAR
-         COLORIZED = COLORIZED//BUFFER
-      ENDIF
-   ENDIF
-   ENDFUNCTION COLORIZE_UCS4
-
-   ELEMENTAL FUNCTION COLOR_INDEX(COLOR)
-   !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED COLOR.
-   !<
-   !< @NOTE BECAUSE FOREGROUND AND BACKROUND COLORS LISTS SHARE THE SAME NAME, NO MATTER WHAT ARRAY IS USED TO FIND THE COLOR INDEX.
-   !< THUS, THE FOREGROUND ARRAY IS USED.
-   CHARACTER(LEN=*), INTENT(IN) :: COLOR       !< COLOR DEFINITION.
-   INTEGER(INT32)               :: COLOR_INDEX !< INDEX INTO THE COLORS ARRAYS.
-   INTEGER(INT32)               :: C           !< COUNTER.
-
-   COLOR_INDEX = 0
-   DO C=1, SIZE(COLORS_FG, DIM=2)
-      IF (TRIM(COLORS_FG(1, C))==TRIM(ADJUSTL(COLOR))) THEN
-         COLOR_INDEX = C
-         EXIT
-      ENDIF
-   ENDDO
-   ENDFUNCTION COLOR_INDEX
-
-   ELEMENTAL FUNCTION STYLE_INDEX(STYLE)
-   !< RETURN THE ARRAY-INDEX CORRESPONDING TO THE QUERIED STYLE.
-   CHARACTER(LEN=*), INTENT(IN) :: STYLE       !< STYLE DEFINITION.
-   INTEGER(INT32)               :: STYLE_INDEX !< INDEX INTO THE STYLES ARRAY.
-   INTEGER(INT32)               :: S           !< COUNTER.
-
-   STYLE_INDEX = 0
-   DO S=1, SIZE(STYLES, DIM=2)
-      IF (TRIM(STYLES(1, S))==TRIM(ADJUSTL(STYLE))) THEN
-         STYLE_INDEX = S
-         EXIT
-      ENDIF
-   ENDDO
-   ENDFUNCTION STYLE_INDEX
-
-   ELEMENTAL FUNCTION UPPER(STRING)
-   !< RETURN A STRING WITH ALL UPPERCASE CHARACTERS.
-   CHARACTER(LEN=*), INTENT(IN) :: STRING !< INPUT STRING.
-   CHARACTER(LEN=LEN(STRING))   :: UPPER  !< UPPER CASE STRING.
-   INTEGER                      :: N1     !< CHARACTERS COUNTER.
-   INTEGER                      :: N2     !< CHARACTERS COUNTER.
-
-   UPPER = STRING
-   DO N1=1, LEN(STRING)
-      N2 = INDEX(LOWER_ALPHABET, STRING(N1:N1))
-      IF (N2>0) UPPER(N1:N1) = UPPER_ALPHABET(N2:N2)
-   ENDDO
-   ENDFUNCTION UPPER
-ENDMODULE FACE
-
-
 
 
 
@@ -3687,7 +3398,6 @@ MODULE STRINGIFOR_STRING_T
 !< STRINGIFOR, DEFINITION OF `STRING` TYPE.
 USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : IOSTAT_EOR
 USE BEFOR64, ONLY : B64_DECODE, B64_ENCODE
-USE FACE, ONLY : COLORIZE
 USE PENF, ONLY : I1P, I2P, I4P, I8P, R4P, R8P, R16P, STR
 
 IMPLICIT NONE
@@ -3730,8 +3440,6 @@ MODULE STRINGIFOR_STRING_T
     PROCEDURE, PASS(SELF) :: CAMELCASE        !< RETURN A STRING WITH ALL WORDS CAPITALIZED WITHOUT SPACES.
     PROCEDURE, PASS(SELF) :: CAPITALIZE       !< RETURN A STRING WITH ITS FIRST CHARACTER CAPITALIZED AND THE REST LOWERCASED.
     PROCEDURE, PASS(SELF) :: CHARS            !< RETURN THE RAW CHARACTERS DATA.
-    GENERIC               :: COLORIZE => &
-                             COLORIZE_STR     !< COLORIZE AND STYLIZE STRINGS.
     PROCEDURE, PASS(SELF) :: DECODE           !< DECODE STRING.
     PROCEDURE, PASS(SELF) :: ENCODE           !< ENCODE STRING.
     PROCEDURE, PASS(SELF) :: ESCAPE           !< ESCAPE BACKSLASHES (OR CUSTOM ESCAPE CHARACTER).
@@ -3849,7 +3557,6 @@ MODULE STRINGIFOR_STRING_T
     PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_STRING    !< VERIFY REPLACEMENT.
     PROCEDURE, PRIVATE, PASS(SELF) :: SVERIFY_STRING_CHARACTER !< VERIFY REPLACEMENT.
     ! AUXILIARY METHODS
-    PROCEDURE, PRIVATE, PASS(SELF) :: COLORIZE_STR     !< COLORIZE AND STYLIZE STRINGS.
     PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_CHARACTER   !< GLOB SEARCH (CHARACTER OUTPUT).
     PROCEDURE, PRIVATE, PASS(SELF) :: GLOB_STRING      !< GLOB SEARCH (STRING OUTPUT).
     PROCEDURE, PRIVATE, PASS(SELF) :: INSERT_STRING    !< INSERT SUBSTRING INTO STRING AT A SPECIFIED POSITION.
@@ -4649,24 +4356,6 @@ PURE FUNCTION CHARS(SELF) RESULT(RAW)
    ENDIF
    ENDFUNCTION CHARS
 
-   PURE FUNCTION COLORIZE_STR(SELF, COLOR_FG, COLOR_BG, STYLE) RESULT(COLORIZED)
-   !< COLORIZE AND STYLIZE STRINGS, DEFAULT KIND.
-   !<
-   !<```FORTRAN
-   !< TYPE(STRING) :: ASTRING
-   !< ASTRING = 'SAY ALL HELLO WORLD!'
-   !< PRINT '(L1)', ASTRING%COLORIZE(COLOR_FG='RED')=='SAY ALL HELLO WORLD!'
-   !<```
-   !=> T <<<
-   CLASS(STRING),    INTENT(IN)           :: SELF      !< THE STRING.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_FG  !< FOREGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: COLOR_BG  !< BACKGROUND COLOR DEFINITION.
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: STYLE     !< STYLE DEFINITION.
-   CHARACTER(LEN=:), ALLOCATABLE          :: COLORIZED !< COLORIZED STRING.
-
-   COLORIZED = COLORIZE(STRING=SELF%CHARS(), COLOR_FG=COLOR_FG, COLOR_BG=COLOR_BG, STYLE=STYLE)
-   ENDFUNCTION COLORIZE_STR
-
    ELEMENTAL FUNCTION DECODE(SELF, CODEC) RESULT(DECODED)
    !< RETURN A STRING DECODED ACCORDINGLY THE CODEC.
    !<
@@ -9539,65 +9228,21 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT
                W_DATA1_RANK1_I4P, &
                W_DATA1_RANK1_I2P, &
                W_DATA1_RANK1_I1P, &
-               W_DATA1_RANK2_R8P, &
-               W_DATA1_RANK2_R4P, &
-               W_DATA1_RANK2_I8P, &
-               W_DATA1_RANK2_I4P, &
-               W_DATA1_RANK2_I2P, &
-               W_DATA1_RANK2_I1P, &
-               W_DATA1_RANK3_R8P, &
-               W_DATA1_RANK3_R4P, &
-               W_DATA1_RANK3_I8P, &
-               W_DATA1_RANK3_I4P, &
-               W_DATA1_RANK3_I2P, &
-               W_DATA1_RANK3_I1P, &
-               W_DATA1_RANK4_R8P, &
-               W_DATA1_RANK4_R4P, &
-               W_DATA1_RANK4_I8P, &
-               W_DATA1_RANK4_I4P, &
-               W_DATA1_RANK4_I2P, &
-               W_DATA1_RANK4_I1P, &
                W_DATA3_RANK1_R8P, &
                W_DATA3_RANK1_R4P, &
                W_DATA3_RANK1_I8P, &
                W_DATA3_RANK1_I4P, &
                W_DATA3_RANK1_I2P, &
                W_DATA3_RANK1_I1P, &
-               W_DATA3_RANK3_R8P, &
-               W_DATA3_RANK3_R4P, &
-               W_DATA3_RANK3_I8P, &
-               W_DATA3_RANK3_I4P, &
-               W_DATA3_RANK3_I2P, &
-               W_DATA3_RANK3_I1P, &
-               W_DATA6_RANK1_R8P, &
-               W_DATA6_RANK1_R4P, &
-               W_DATA6_RANK1_I8P, &
-               W_DATA6_RANK1_I4P, &
-               W_DATA6_RANK1_I2P, &
-               W_DATA6_RANK1_I1P, &
-               W_DATA6_RANK3_R8P, &
-               W_DATA6_RANK3_R4P, &
-               W_DATA6_RANK3_I8P, &
-               W_DATA6_RANK3_I4P, &
-               W_DATA6_RANK3_I2P, &
-               W_DATA6_RANK3_I1P, &
                W_DATA_LOCATION_TAG !< WRITE DATA (ARRAY).
     GENERIC :: WRITE_FIELDDATA =>      &
                WRITE_FIELDDATA1_RANK0, &
                WRITE_FIELDDATA_TAG !< WRITE FIELDDATA TAG.
     GENERIC :: WRITE_GEO =>                    &
-               WRITE_GEO_STRG_DATA1_RANK2_R8P, &
-               WRITE_GEO_STRG_DATA1_RANK2_R4P, &
-               WRITE_GEO_STRG_DATA1_RANK4_R8P, &
-               WRITE_GEO_STRG_DATA1_RANK4_R4P, &
                WRITE_GEO_STRG_DATA3_RANK1_R8P, &
                WRITE_GEO_STRG_DATA3_RANK1_R4P, &
-               WRITE_GEO_STRG_DATA3_RANK3_R8P, &
-               WRITE_GEO_STRG_DATA3_RANK3_R4P, &
                WRITE_GEO_RECT_DATA3_RANK1_R8P, &
                WRITE_GEO_RECT_DATA3_RANK1_R4P, &
-               WRITE_GEO_UNST_DATA1_RANK2_R8P, &
-               WRITE_GEO_UNST_DATA1_RANK2_R4P, &
                WRITE_GEO_UNST_DATA3_RANK1_R8P, &
                WRITE_GEO_UNST_DATA3_RANK1_R4P !< WRITE MESH.
     GENERIC :: WRITE_PARALLEL_BLOCK_FILES =>     &
@@ -9615,68 +9260,22 @@ MODULE VTKF_FILE_XML_WRITER_ABSTRACT
     PROCEDURE(W_DATA1_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I4P !< DATA 1, RANK 1, I4P.
     PROCEDURE(W_DATA1_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I2P !< DATA 1, RANK 1, I2P.
     PROCEDURE(W_DATA1_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK1_I1P !< DATA 1, RANK 1, I1P.
-    PROCEDURE(W_DATA1_RANK2_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R8P !< DATA 1, RANK 2, R8P.
-    PROCEDURE(W_DATA1_RANK2_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_R4P !< DATA 1, RANK 2, R4P.
-    PROCEDURE(W_DATA1_RANK2_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I8P !< DATA 1, RANK 2, I8P.
-    PROCEDURE(W_DATA1_RANK2_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I4P !< DATA 1, RANK 2, I4P.
-    PROCEDURE(W_DATA1_RANK2_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I2P !< DATA 1, RANK 2, I2P.
-    PROCEDURE(W_DATA1_RANK2_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK2_I1P !< DATA 1, RANK 2, I1P.
-    PROCEDURE(W_DATA1_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R8P !< DATA 1, RANK 3, R8P.
-    PROCEDURE(W_DATA1_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_R4P !< DATA 1, RANK 3, R4P.
-    PROCEDURE(W_DATA1_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I8P !< DATA 1, RANK 3, I8P.
-    PROCEDURE(W_DATA1_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I4P !< DATA 1, RANK 3, I4P.
-    PROCEDURE(W_DATA1_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I2P !< DATA 1, RANK 3, I2P.
-    PROCEDURE(W_DATA1_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK3_I1P !< DATA 1, RANK 3, I1P.
-    PROCEDURE(W_DATA1_RANK4_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R8P !< DATA 1, RANK 4, R8P.
-    PROCEDURE(W_DATA1_RANK4_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_R4P !< DATA 1, RANK 4, R4P.
-    PROCEDURE(W_DATA1_RANK4_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I8P !< DATA 1, RANK 4, I8P.
-    PROCEDURE(W_DATA1_RANK4_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I4P !< DATA 1, RANK 4, I4P.
-    PROCEDURE(W_DATA1_RANK4_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I2P !< DATA 1, RANK 4, I2P.
-    PROCEDURE(W_DATA1_RANK4_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA1_RANK4_I1P !< DATA 1, RANK 4, I1P.
     PROCEDURE(W_DATA3_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R8P !< DATA 3, RANK 1, R8P.
     PROCEDURE(W_DATA3_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_R4P !< DATA 3, RANK 1, R4P.
     PROCEDURE(W_DATA3_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I8P !< DATA 3, RANK 1, I8P.
     PROCEDURE(W_DATA3_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I4P !< DATA 3, RANK 1, I4P.
     PROCEDURE(W_DATA3_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I2P !< DATA 3, RANK 1, I2P.
     PROCEDURE(W_DATA3_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK1_I1P !< DATA 3, RANK 1, I1P.
-    PROCEDURE(W_DATA3_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R8P !< DATA 3, RANK 3, R8P.
-    PROCEDURE(W_DATA3_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_R4P !< DATA 3, RANK 3, R4P.
-    PROCEDURE(W_DATA3_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I8P !< DATA 3, RANK 3, I8P.
-    PROCEDURE(W_DATA3_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I4P !< DATA 3, RANK 3, I4P.
-    PROCEDURE(W_DATA3_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I2P !< DATA 3, RANK 3, I2P.
-    PROCEDURE(W_DATA3_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA3_RANK3_I1P !< DATA 3, RANK 3, I1P.
-    PROCEDURE(W_DATA6_RANK1_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R8P !< DATA 3, RANK 1, R8P.
-    PROCEDURE(W_DATA6_RANK1_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_R4P !< DATA 3, RANK 1, R4P.
-    PROCEDURE(W_DATA6_RANK1_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I8P !< DATA 3, RANK 1, I8P.
-    PROCEDURE(W_DATA6_RANK1_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I4P !< DATA 3, RANK 1, I4P.
-    PROCEDURE(W_DATA6_RANK1_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I2P !< DATA 3, RANK 1, I2P.
-    PROCEDURE(W_DATA6_RANK1_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK1_I1P !< DATA 3, RANK 1, I1P.
-    PROCEDURE(W_DATA6_RANK3_R8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R8P !< DATA 3, RANK 3, R8P.
-    PROCEDURE(W_DATA6_RANK3_R4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_R4P !< DATA 3, RANK 3, R4P.
-    PROCEDURE(W_DATA6_RANK3_I8P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I8P !< DATA 3, RANK 3, I8P.
-    PROCEDURE(W_DATA6_RANK3_I4P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I4P !< DATA 3, RANK 3, I4P.
-    PROCEDURE(W_DATA6_RANK3_I2P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I2P !< DATA 3, RANK 3, I2P.
-    PROCEDURE(W_DATA6_RANK3_I1P_INTERFACE), DEFERRED, PASS(SELF) :: W_DATA6_RANK3_I1P !< DATA 3, RANK 3, I1P.
     PROCEDURE(W_DATA_APPENDED_INTERFACE),   DEFERRED, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
     ! PRIVATE METHODS
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA1_RANK0            !< WRITE FIELDDATA TAG (DATA 1, RANK 0, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_FIELDDATA_TAG               !< WRITE FIELDDATA TAG.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK2_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R8P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA1_RANK4_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 1, RANK 4, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK1_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R8P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R8P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_STRG_DATA3_RANK3_R4P    !< WRITE **STRUCTUREDGRID** MESH (DATA 3, RANK 3, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R8P    !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_RECT_DATA3_RANK1_R4P    !< WRITE **RECTILINEARGRID** MESH (DATA 3, RANK 1, R4P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R8P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R8P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA1_RANK2_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 1, RANK 2, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R8P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_UNST_DATA3_RANK1_R4P    !< WRITE **UNSTRUCTUREDGRID** MESH (DATA 3, RANK 1, R4P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R8P    !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R8P).
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA1_RANK2_R4P    !< WRITE **POLYDATA** MESH (DATA 1, RANK 2, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R8P    !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R8P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_GEO_POLY_DATA3_RANK1_R4P    !< WRITE **POLYDATA** MESH (DATA 3, RANK 1, R4P).
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_PIECE_START_TAG             !< WRITE `<PIECE ...>` START TAG.
@@ -9774,204 +9373,6 @@ FUNCTION W_DATA1_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR
   INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
   ENDFUNCTION W_DATA1_RANK1_I1P_INTERFACE
 
-  FUNCTION W_DATA1_RANK2_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_R8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK2_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_R4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK2_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_I8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK2_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_I4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK2_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_I2P_INTERFACE
-
-  FUNCTION W_DATA1_RANK2_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK2_I1P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_R8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_R4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_I8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_I4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_I2P_INTERFACE
-
-  FUNCTION W_DATA1_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK3_I1P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_R8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_R8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_R4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_R4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_I8P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_I8P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_I4P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_I4P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_I2P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_I2P_INTERFACE
-
-  FUNCTION W_DATA1_RANK4_I1P_INTERFACE(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  ENDFUNCTION W_DATA1_RANK4_I1P_INTERFACE
-
   FUNCTION W_DATA3_RANK1_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
   IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
@@ -10044,258 +9445,6 @@ FUNCTION W_DATA3_RANK1_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT
   INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
   ENDFUNCTION W_DATA3_RANK1_I1P_INTERFACE
 
-  FUNCTION W_DATA3_RANK3_R8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_R8P_INTERFACE
-
-  FUNCTION W_DATA3_RANK3_R4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_R4P_INTERFACE
-
-  FUNCTION W_DATA3_RANK3_I8P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_I8P_INTERFACE
-
-  FUNCTION W_DATA3_RANK3_I4P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_I4P_INTERFACE
-
-  FUNCTION W_DATA3_RANK3_I2P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_I2P_INTERFACE
-
-  FUNCTION W_DATA3_RANK3_I1P_INTERFACE(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA3_RANK3_I1P_INTERFACE
-  
-  FUNCTION W_DATA6_RANK1_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_R8P_INTERFACE
-
-  FUNCTION W_DATA6_RANK1_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_R4P_INTERFACE
-
-  FUNCTION W_DATA6_RANK1_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_I8P_INTERFACE
-
-  FUNCTION W_DATA6_RANK1_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_I4P_INTERFACE
-
-  FUNCTION W_DATA6_RANK1_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_I2P_INTERFACE
-
-  FUNCTION W_DATA6_RANK1_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK1_I1P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_R8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_R8P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_R4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, R4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_R4P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_I8P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P, I8P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_I8P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_I4P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  IMPORT :: XML_WRITER_ABSTRACT, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_I4P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_I2P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  IMPORT :: XML_WRITER_ABSTRACT, I2P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_I2P_INTERFACE
-
-  FUNCTION W_DATA6_RANK3_I1P_INTERFACE(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  IMPORT :: XML_WRITER_ABSTRACT, I1P, I4P
-  CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  ENDFUNCTION W_DATA6_RANK3_I1P_INTERFACE
-
   SUBROUTINE W_DATA_APPENDED_INTERFACE(SELF)
   !< WRITE `<APPENDEDDATA...>...</APPENDEDDATA>` TAG.
   IMPORT :: XML_WRITER_ABSTRACT
@@ -10721,62 +9870,14 @@ FUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P(SELF, X, Y, Z) RESULT(ERROR)
    ENDFUNCTION WRITE_GEO_RECT_DATA3_RANK1_R4P
 
    ! WRITE_GEO_STRG METHODS
-   FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P(SELF, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,1:N].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R8P
-
-   FUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P(SELF, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK2_R4P
-
-   FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P(SELF, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF             !< WRITER.
-   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:].
-   INTEGER(I4P)                              :: ERROR            !< ERROR STATUS.
-
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R8P
-
-   FUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P(SELF, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 4, R4P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF             !< WRITER.
-   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:,1:,1:) !< X, Y, Z COORDINATES [1:3,:,:,:].
-   INTEGER(I4P)                              :: ERROR            !< ERROR STATUS.
-
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA1_RANK4_R4P
-
-   FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: N     !< NUMBER OF NODES.
-   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
-   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
-   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
-   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
+   FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R8P(SELF, N, X, Y, Z) RESULT(ERROR)
+   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
+   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P),               INTENT(IN)    :: N     !< NUMBER OF NODES.
+   REAL(R8P),                  INTENT(IN)    :: X(1:) !< X COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Y(1:) !< Y COORDINATES.
+   REAL(R8P),                  INTENT(IN)    :: Z(1:) !< Z COORDINATES.
+   INTEGER(I4P)                              :: ERROR !< ERROR STATUS.
 
    IF ((N/=SIZE(X, DIM=1)).OR.(N/=SIZE(Y, DIM=1)).OR.(N/=SIZE(Z, DIM=1))) THEN
       SELF%ERROR = 1
@@ -10807,85 +9908,7 @@ FUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P(SELF, N, X, Y, Z) RESULT(ERROR)
    ERROR = SELF%ERROR
    ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK1_R4P
 
-   FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P(SELF, N, X, Y, Z) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF        !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: N           !< NUMBER OF NODES.
-   REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COORDINATES.
-   REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COORDINATES.
-   REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COORDINATES.
-   INTEGER(I4P)                              :: ERROR       !< ERROR STATUS.
-
-   IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.&
-       (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.&
-       (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R8P
-
-   FUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P(SELF, N, X, Y, Z) RESULT(ERROR)
-   !< WRITE MESH WITH **STRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 3, R4P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF        !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: N           !< NUMBER OF NODES.
-   REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COORDINATES.
-   REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COORDINATES.
-   REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COORDINATES.
-   INTEGER(I4P)                              :: ERROR       !< ERROR STATUS.
-
-   IF ((N/=SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)).OR.&
-       (N/=SIZE(Y, DIM=1)*SIZE(Y, DIM=2)*SIZE(Y, DIM=3)).OR.&
-       (N/=SIZE(Z, DIM=1)*SIZE(Z, DIM=2)*SIZE(Z, DIM=3))) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_STRG_DATA3_RANK3_R4P
-
    ! WRITE_GEO_UNST METHODS
-   FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
-   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
-   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   IF (NP/=SIZE(XYZ, DIM=2)) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R8P
-
-   FUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 1, RANK 2, R4P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
-   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
-   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   IF (NP/=SIZE(XYZ, DIM=2)) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_UNST_DATA1_RANK2_R4P
-
    FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
    !< WRITE MESH WITH **UNSTRUCTUREDGRID** TOPOLOGY (DATA 3, RANK 1, R8P).
    CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
@@ -10927,42 +9950,6 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
    ENDFUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P
 
    ! WRITE_GEO_POLY METHODS
-   FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P(SELF, NP, NC, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R8P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
-   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
-   REAL(R8P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   IF (NP/=SIZE(XYZ, DIM=2)) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R8P
-
-   FUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P(SELF, NP, NC, XYZ) RESULT(ERROR)
-   !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 1, RANK 2, R4P).
-   CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF       !< WRITER.
-   INTEGER(I4P),               INTENT(IN)    :: NP         !< NUMBER OF POINTS.
-   INTEGER(I4P),               INTENT(IN)    :: NC         !< NUMBER OF CELLS.
-   REAL(R4P),                  INTENT(IN)    :: XYZ(1:,1:) !< X, Y, Z COORDINATES [1:3,:].
-   INTEGER(I4P)                              :: ERROR      !< ERROR STATUS.
-
-   IF (NP/=SIZE(XYZ, DIM=2)) THEN
-      SELF%ERROR = 1
-      RETURN
-   ENDIF
-   CALL SELF%WRITE_START_TAG(NAME='Points')
-   ERROR = SELF%W_DATA(DATA_NAME='Points', X=XYZ)
-   CALL SELF%WRITE_END_TAG(NAME='Points')
-   ERROR = SELF%ERROR
-   ENDFUNCTION WRITE_GEO_POLY_DATA1_RANK2_R4P
-
    FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
    !< WRITE MESH WITH **POLYDATA** TOPOLOGY (DATA 3, RANK 1, R8P).
    CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT) :: SELF  !< WRITER.
@@ -11280,48 +10267,12 @@ MODULE VTK_FORTRAN_DATAARRAY_ENCODER
                    ENCODE_ASCII_DATAARRAY1_RANK1_I4P, &
                    ENCODE_ASCII_DATAARRAY1_RANK1_I2P, &
                    ENCODE_ASCII_DATAARRAY1_RANK1_I1P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_R8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_R4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_I8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_I4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_I2P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK2_I1P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_R8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_R4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_I8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_I4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_I2P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK3_I1P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_R8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_R4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_I8P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_I4P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_I2P, &
-                   ENCODE_ASCII_DATAARRAY1_RANK4_I1P, &
                    ENCODE_ASCII_DATAARRAY3_RANK1_R8P, &
                    ENCODE_ASCII_DATAARRAY3_RANK1_R4P, &
                    ENCODE_ASCII_DATAARRAY3_RANK1_I8P, &
                    ENCODE_ASCII_DATAARRAY3_RANK1_I4P, &
                    ENCODE_ASCII_DATAARRAY3_RANK1_I2P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK1_I1P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_R8P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_R4P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_I8P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_I4P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_I2P, &
-                   ENCODE_ASCII_DATAARRAY3_RANK3_I1P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_R8P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_R4P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_I8P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_I4P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_I2P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK1_I1P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_R8P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_R4P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_I8P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_I4P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_I2P, &
-                   ENCODE_ASCII_DATAARRAY6_RANK3_I1P
+                   ENCODE_ASCII_DATAARRAY3_RANK1_I1P
 ENDINTERFACE ENCODE_ASCII_DATAARRAY
 INTERFACE ENCODE_BINARY_DATAARRAY
   !< BINARY (BASE64) DATAARRAY ENCODER.
@@ -11331,48 +10282,12 @@ MODULE VTK_FORTRAN_DATAARRAY_ENCODER
                    ENCODE_BINARY_DATAARRAY1_RANK1_I4P, &
                    ENCODE_BINARY_DATAARRAY1_RANK1_I2P, &
                    ENCODE_BINARY_DATAARRAY1_RANK1_I1P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_R8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_R4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_I8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_I4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_I2P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK2_I1P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_R8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_R4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_I8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_I4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_I2P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK3_I1P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_R8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_R4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_I8P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_I4P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_I2P, &
-                   ENCODE_BINARY_DATAARRAY1_RANK4_I1P, &
                    ENCODE_BINARY_DATAARRAY3_RANK1_R8P, &
                    ENCODE_BINARY_DATAARRAY3_RANK1_R4P, &
                    ENCODE_BINARY_DATAARRAY3_RANK1_I8P, &
                    ENCODE_BINARY_DATAARRAY3_RANK1_I4P, &
                    ENCODE_BINARY_DATAARRAY3_RANK1_I2P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK1_I1P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_R8P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_R4P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_I8P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_I4P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_I2P, &
-                   ENCODE_BINARY_DATAARRAY3_RANK3_I1P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_R8P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_R4P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_I8P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_I4P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_I2P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK1_I1P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_R8P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_R4P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_I8P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_I4P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_I2P, &
-                   ENCODE_BINARY_DATAARRAY6_RANK3_I1P
+                   ENCODE_BINARY_DATAARRAY3_RANK1_I1P
 ENDINTERFACE ENCODE_BINARY_DATAARRAY
 CONTAINS
   !< ASCII ENCODER
@@ -11509,656 +10424,6 @@ FUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P(X) RESULT(CODE)
   ENDDO
   ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK1_I1P
 
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R16P).
-  REAL(R16P),      INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DR16P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L 
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P).
-  REAL(R8P),       INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DR8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P).
-  REAL(R4P),       INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DR4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DI8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DI4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DI4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
-  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1       !< COUNTER.
-  INTEGER(I4P)                  :: N2       !< COUNTER.
-  INTEGER(I4P)                  :: L        !< LENGTH
-  INTEGER(I4P)                  :: SP       !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1  !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2  !< DIMENSION 2 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  L = DI1P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2)
-  DO N2=1, SIZE(X, DIM=2)
-    DO N1=1, SIZE(X, DIM=1)-1
-      CODE(SP+1:SP+L) = STR(N=X(N1, N2))//' '
-      SP = SP + L
-    ENDDO
-    CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK2_I1P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R16P).
-  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR16P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + 1
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH 
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI2P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI1P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)-1
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '
-        SP = SP + L
-      ENDDO
-      CODE(SP+1:SP+L) = ' '//STR(N=X(SIZE(X, DIM=1), N2, N3))
-      SP = SP + L
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK3_I1P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R16P).
-  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DR16P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P).
-  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DR8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P).
-  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DR4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DI8P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DI4P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DI2P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P).
-  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1             !< COUNTER.
-  INTEGER(I4P)                  :: N2             !< COUNTER.
-  INTEGER(I4P)                  :: N3             !< COUNTER.
-  INTEGER(I4P)                  :: N4             !< COUNTER.
-  INTEGER(I4P)                  :: L              !< LENGTH
-  INTEGER(I4P)                  :: SP             !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1        !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2        !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3        !< DIMENSION 3 SIZE
-  INTEGER(I4P)                  :: SIZE_N4        !< DIMENSION 4 SIZE
-  
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  SIZE_N3 = SIZE(X, DIM=4)
-  
-  L = DI1P + 1
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3*SIZE_N4)
-  DO N4=1, SIZE(X, DIM=4)
-    DO N3=1, SIZE(X, DIM=3)
-      DO N2=1, SIZE(X, DIM=2)
-        DO N1=1, SIZE(X, DIM=1)
-          CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3, N4))//' '
-          SP = SP + L
-        ENDDO
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY1_RANK4_I1P
-
   FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_R16P(X, Y, Z) RESULT(CODE)
   !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R16P).
   REAL(R16P),      INTENT(IN)   :: X(1:) !< X COMPONENT.
@@ -12306,657 +10571,6 @@ FUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE)
   ENDDO
   ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK1_I1P
 
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
-  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR16P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR8P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR4P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI8P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI4P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI2P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI1P*3 + 2
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE(X, DIM=3)
-    DO N2=1, SIZE(X, DIM=2)
-      DO N1=1, SIZE(X, DIM=1)
-        CODE(SP+1:SP+L) = STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY3_RANK3_I1P
-  
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R16P).
-  REAL(R16P),      INTENT(IN)   :: U(1:) !< U COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: V(1:) !< V COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: W(1:) !< W COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: X(1:) !< X COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-  
-  SIZE_N = SIZE(X, DIM=1)
-  L = DR16P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
-  REAL(R8P),       INTENT(IN)   :: U(1:) !< U COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: V(1:) !< V COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: W(1:) !< W COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DR8P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
-  REAL(R4P),       INTENT(IN)   :: U(1:) !< U COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: V(1:) !< V COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: W(1:) !< W COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: X(1:) !< X COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DR4P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DI8P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DI4P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DI2P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
-  INTEGER(I1P),    INTENT(IN)   :: U(1:) !< U COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: V(1:) !< V COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: W(1:) !< W COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: X(1:) !< X COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Y(1:) !< Y COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Z(1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE  !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N     !< COUNTER.
-  INTEGER(I4P)                  :: L     !< LENGTH
-  INTEGER(I4P)                  :: SP    !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N!< DIMENSION 1 SIZE
-
-  SIZE_N = SIZE(X, DIM=1)
-  L = DI1P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N)
-  DO N=1, SIZE_N
-    CODE(SP+1:SP+L) = STR(N=U(N))//' '//STR(N=V(N))//' '//STR(N=W(N))// &
-                STR(N=X(N))//' '//STR(N=Y(N))//' '//STR(N=Z(N))
-    SP = SP + L
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK1_I1P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
-  REAL(R16P),      INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R16P),      INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR16P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R16P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P),       INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR8P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P),       INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),       INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DR4P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_R4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI8P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I8P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI4P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I4P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI2P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I2P
-
-  FUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P),    INTENT(IN)   :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),    INTENT(IN)   :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-  INTEGER(I4P)                  :: L           !< LENGTH
-  INTEGER(I4P)                  :: SP          !< STRING POINTER
-  INTEGER(I4P)                  :: SIZE_N1     !< DIMENSION 1 SIZE
-  INTEGER(I4P)                  :: SIZE_N2     !< DIMENSION 2 SIZE
-  INTEGER(I4P)                  :: SIZE_N3     !< DIMENSION 3 SIZE
-
-  SIZE_N1 = SIZE(X, DIM=1)
-  SIZE_N2 = SIZE(X, DIM=2)
-  SIZE_N3 = SIZE(X, DIM=3)
-  
-  L = DI1P*6 + 5
-  SP = 0
-  CODE = REPEAT(' ',L*SIZE_N1*SIZE_N2*SIZE_N3)
-  DO N3=1, SIZE_N3
-    DO N2=1, SIZE_N2
-      DO N1=1, SIZE_N1
-        CODE(SP+1:SP+L) = STR(N=U(N1, N2, N3))//' '//STR(N=V(N1, N2, N3))//' '//STR(N=W(N1, N2, N3))// &
-          STR(N=X(N1, N2, N3))//' '//STR(N=Y(N1, N2, N3))//' '//STR(N=Z(N1, N2, N3))
-        SP = SP + L
-      ENDDO
-    ENDDO
-  ENDDO
-  ENDFUNCTION ENCODE_ASCII_DATAARRAY6_RANK3_I1P
-
   !< BINARY ENCODER
   FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_R8P(X) RESULT(CODE)
   !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 1 (R8P).
@@ -13030,222 +10644,6 @@ FUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P(X) RESULT(CODE)
   CALL B64_ENCODE(N=XP, CODE=CODE)
   ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK1_I1P
 
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R8P).
-  REAL(R8P), INTENT(IN)         :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (R4P).
-  REAL(R4P), INTENT(IN)         :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_R4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 2 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: X(1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE     !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)    !< PACKED DATA.
-  INTEGER(I4P)                  :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK2_I1P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P), INTENT(IN)         :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P), INTENT(IN)         :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_R4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< DATA VARIABLE
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)       !< PACKED DATA.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK3_I1P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R8P).
-  REAL(R8P), INTENT(IN)         :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  CALL PACK_DATA(A1=[INT(NN*BYR8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (R4P).
-  REAL(R4P), INTENT(IN)         :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  CALL PACK_DATA(A1=[INT(NN*BYR4P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_R4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  CALL PACK_DATA(A1=[INT(NN*BYI8P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  XP = TRANSFER([INT(NN*BYI4P, I4P), RESHAPE(X, [NN])], XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  CALL PACK_DATA(A1=[INT(NN*BYI2P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P(X) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 1 COMPONENTS OF RANK 4 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE           !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XP(:)          !< PACKED DATA.
-  INTEGER(I4P)                  :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  CALL PACK_DATA(A1=[INT(NN*BYI1P, I4P)], A2=RESHAPE(X, [NN]), PACKED=XP)
-  CALL B64_ENCODE(N=XP, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY1_RANK4_I1P
-
   FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_R8P(X, Y, Z) RESULT(CODE)
   !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
   REAL(R8P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
@@ -13335,463 +10733,22 @@ FUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P(X, Y, Z) RESULT(CODE)
   CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
   CALL B64_ENCODE(N=XYZ, CODE=CODE)
   ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK1_I1P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(3*NN*BYR8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(3*NN*BYR4P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_R4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(3*NN*BYI8P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  XYZ = TRANSFER([INT(3*NN*BYI4P, I4P), [(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                         N2=1, NN2),  &
-                                                                                         N3=1, NN3)]], XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(3*NN*BYI2P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P(X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(3*NN*BYI1P, I4P)], A2=[(((X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY3_RANK3_I1P
   
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
-  REAL(R8P),    INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
-
-  NN = SIZE(X, DIM=1)
-  CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R8P
+ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER
 
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
-  REAL(R4P),    INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
 
-  NN = SIZE(X, DIM=1)
-  CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_R4P
 
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
+!< VTK FILE XML WRITER, ASCII LOCAL.
+MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+!< VTK FILE XML WRITER, ASCII LOCAL.
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_DATAARRAY_ENCODER
+USE VTKF_FILE_XML_WRITER_ABSTRACT
 
-  NN = SIZE(X, DIM=1)
-  CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
-
-  NN = SIZE(X, DIM=1)
-  XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)]], XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
-
-  NN = SIZE(X, DIM=1)
-  CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: U(1:)  !< U COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: V(1:)  !< V COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: W(1:)  !< W COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: X(1:)  !< X COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Z(1:)  !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE   !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:) !< PACKED DATA.
-  INTEGER(I4P)                  :: NN     !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N      !< COUNTER.
-
-  NN = SIZE(X, DIM=1)
-  CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1, NN)], PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ, CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK1_I1P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
-  REAL(R8P),    INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(6*NN*BYR8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P).
-  REAL(R4P),    INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),    INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(6*NN*BYR4P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_R4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
-  INTEGER(I8P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(6*NN*BYI8P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I8P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
-  INTEGER(I4P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  XYZ = TRANSFER([INT(6*NN*BYI4P, I4P), [(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                            X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                         N2=1, NN2),  &
-                                                                                         N3=1, NN3)]], XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I4P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
-  INTEGER(I2P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(6*NN*BYI2P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I2P
-
-  FUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P(U, V, W, X, Y, Z) RESULT(CODE)
-  !< ENCODE (BASE64) A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
-  INTEGER(I1P), INTENT(IN)      :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P), INTENT(IN)      :: Z(1:,1:,1:) !< Z COMPONENT.
-  CHARACTER(LEN=:), ALLOCATABLE :: CODE        !< ENCODED BASE64 DATAARRAY.
-  INTEGER(I1P),     ALLOCATABLE :: XYZ(:)      !< PACKED DATA.
-  INTEGER(I4P)                  :: NN1         !< NUMBER OF ELEMENTS ALONG DIM 1.
-  INTEGER(I4P)                  :: NN2         !< NUMBER OF ELEMENTS ALONG DIM 2.
-  INTEGER(I4P)                  :: NN3         !< NUMBER OF ELEMENTS ALONG DIM 3.
-  INTEGER(I4P)                  :: NN          !< NUMBER OF ELEMENTS.
-  INTEGER(I4P)                  :: N1          !< COUNTER.
-  INTEGER(I4P)                  :: N2          !< COUNTER.
-  INTEGER(I4P)                  :: N3          !< COUNTER.
-
-  NN1 = SIZE(X, DIM=1)
-  NN2 = SIZE(X, DIM=2)
-  NN3 = SIZE(X, DIM=3)
-  NN = NN1*NN2*NN3
-  CALL PACK_DATA(A1=[INT(6*NN*BYI1P, I4P)], A2=[(((U(N1, N2, N3), V(N1, N2, N3), W(N1, N2, N3), &
-                                                   X(N1, N2, N3), Y(N1, N2, N3), Z(N1, N2, N3), N1=1, NN1),  &
-                                                                                                N2=1, NN2),  &
-                                                                                                N3=1, NN3)], &
-                 PACKED=XYZ)
-  CALL B64_ENCODE(N=XYZ,CODE=CODE)
-  ENDFUNCTION ENCODE_BINARY_DATAARRAY6_RANK3_I1P
-ENDMODULE VTK_FORTRAN_DATAARRAY_ENCODER
-
-
-
-!< VTK FILE XML WRITER, ASCII LOCAL.
-MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
-!< VTK FILE XML WRITER, ASCII LOCAL.
-USE PENF
-USE STRINGIFOR
-USE VTK_FORTRAN_DATAARRAY_ENCODER
-USE VTKF_FILE_XML_WRITER_ABSTRACT
-
-IMPLICIT NONE
-PRIVATE
-PUBLIC :: XML_WRITER_ASCII_LOCAL
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_ASCII_LOCAL
 
 TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_ASCII_LOCAL
   !< VTK FILE XML WRITER, ASCII LOCAL.
@@ -13805,48 +10762,12 @@ MODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
     PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
 ENDTYPE XML_WRITER_ASCII_LOCAL
 CONTAINS
@@ -14002,420 +10923,6 @@ FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
   ERROR = SELF%ERROR
   ENDFUNCTION W_DATA1_RANK1_I1P
 
-  FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_R8P
-
-  FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_R4P
-
-  FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I8P
-
-  FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I4P
-
-  FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I2P
-
-  FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I1P
-
-  FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_R8P
-
-  FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_R4P
-
-  FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I8P
-
-  FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I4P
-
-  FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I2P
-
-  FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I1P
-
-  FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_R8P
-
-  FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_R4P
-
-  FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I8P
-
-  FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I4P
-
-  FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I2P
-
-  FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE           !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CODE = ENCODE_ASCII_DATAARRAY(X=X)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I1P
-
   FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
   CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
@@ -14541,427 +11048,12 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
                                 IS_TUPLES=IS_TUPLES)
   ERROR = SELF%ERROR
   ENDFUNCTION W_DATA3_RANK1_I1P
-
-  FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_R8P
-
-  FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_R4P
-
-  FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I8P
-
-  FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I4P
-
-  FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I2P
-
-  FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 3
-  CODE = ENCODE_ASCII_DATAARRAY(X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I1P
-
-  FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_R8P
-
-  FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W,X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_R4P
-
-  FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I8P
-
-  FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I4P
-
-  FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I2P
-
-  FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I1P
-
-  FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                     INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_R8P
-
-  FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                     INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                     INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_R4P
-
-  FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I8P
-
-  FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I4P
-
-  FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I2P
-
-  FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),                  INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                        :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-  CHARACTER(LEN=:), ALLOCATABLE                       :: CODE         !< DATA VARIABLE ENCODED, ASCII OR BASE64 CODEC.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 6
-  CODE = ENCODE_ASCII_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-  CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                IS_TUPLES=IS_TUPLES)
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I1P
-
-  
-  SUBROUTINE W_DATA_APPENDED(SELF)
-  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
-  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
-  ENDSUBROUTINE W_DATA_APPENDED
-ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
+  
+  SUBROUTINE W_DATA_APPENDED(SELF)
+  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
+  CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
+  ENDSUBROUTINE W_DATA_APPENDED
+ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
 
 
 
@@ -14995,48 +11087,12 @@ MODULE VTKF_FILE_XML_WRITER_APPENDED
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
     PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
     PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
-    PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
     PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
     ! PRIVATE METHODS
     PROCEDURE, PASS(SELF), PRIVATE :: IOFFSET_UPDATE     !< UPDATE IOFFSET COUNT.
@@ -15044,85 +11100,19 @@ MODULE VTKF_FILE_XML_WRITER_APPENDED
     PROCEDURE, PASS(SELF), PRIVATE :: CLOSE_SCRATCH_FILE !< CLOSE SCRATCH FILE.
     GENERIC, PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY =>          &
                         WRITE_ON_SCRATCH_DATAARRAY1_RANK1,     &
-                        WRITE_ON_SCRATCH_DATAARRAY1_RANK2,     &
-                        WRITE_ON_SCRATCH_DATAARRAY1_RANK3,     &
-                        WRITE_ON_SCRATCH_DATAARRAY1_RANK4,     &
                         WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P, &
                         WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P, &
                         WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P, &
                         WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P, &
                         WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P, &
-                        WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY.
+                        WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK1     !< WRITE DATAARRAY, DATA 1 RANK 1.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK2     !< WRITE DATAARRAY, DATA 1 RANK 2.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK3     !< WRITE DATAARRAY, DATA 1 RANK 3.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY1_RANK4     !< WRITE DATAARRAY, DATA 1 RANK 4.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P !< WRITE DATAARRAY, COMP 3 RANK 1, R8P.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P !< WRITE DATAARRAY, COMP 3 RANK 1, R4P.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P !< WRITE DATAARRAY, COMP 3 RANK 1, I8P.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P !< WRITE DATAARRAY, COMP 3 RANK 1, I4P.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P !< WRITE DATAARRAY, COMP 3 RANK 1, I2P.
     PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P !< WRITE DATAARRAY, COMP 3 RANK 1, I1P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P !< WRITE DATAARRAY, COMP 3 RANK 2, R8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P !< WRITE DATAARRAY, COMP 3 RANK 2, R4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P !< WRITE DATAARRAY, COMP 3 RANK 2, I8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P !< WRITE DATAARRAY, COMP 3 RANK 2, I4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P !< WRITE DATAARRAY, COMP 3 RANK 2, I2P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P !< WRITE DATAARRAY, COMP 3 RANK 2, I1P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P !< WRITE DATAARRAY, COMP 3 RANK 3, R8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P !< WRITE DATAARRAY, COMP 3 RANK 3, R4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P !< WRITE DATAARRAY, COMP 3 RANK 3, I8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P !< WRITE DATAARRAY, COMP 3 RANK 3, I4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P !< WRITE DATAARRAY, COMP 3 RANK 3, I2P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P !< WRITE DATAARRAY, COMP 3 RANK 3, I1P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P !< WRITE DATAARRAY, COMP 6 RANK 1, R8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P !< WRITE DATAARRAY, COMP 6 RANK 1, R4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P !< WRITE DATAARRAY, COMP 6 RANK 1, I8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P !< WRITE DATAARRAY, COMP 6 RANK 1, I4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P !< WRITE DATAARRAY, COMP 6 RANK 1, I2P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P !< WRITE DATAARRAY, COMP 6 RANK 1, I1P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P !< WRITE DATAARRAY, COMP 6 RANK 2, R8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P !< WRITE DATAARRAY, COMP 6 RANK 2, R4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P !< WRITE DATAARRAY, COMP 6 RANK 2, I8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P !< WRITE DATAARRAY, COMP 6 RANK 2, I4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P !< WRITE DATAARRAY, COMP 6 RANK 2, I2P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P !< WRITE DATAARRAY, COMP 6 RANK 2, I1P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P !< WRITE DATAARRAY, COMP 6 RANK 3, R8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P !< WRITE DATAARRAY, COMP 6 RANK 3, R4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P !< WRITE DATAARRAY, COMP 6 RANK 3, I8P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P !< WRITE DATAARRAY, COMP 6 RANK 3, I4P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P !< WRITE DATAARRAY, COMP 6 RANK 3, I2P.
-    PROCEDURE, PASS(SELF), PRIVATE :: WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P !< WRITE DATAARRAY, COMP 6 RANK 3, I1P.
 ENDTYPE XML_WRITER_APPENDED
 CONTAINS
   FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
@@ -15313,421 +11303,25 @@ FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
   ERROR = SELF%ERROR
   ENDFUNCTION W_DATA1_RANK1_I1P
 
-  FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
+  FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
+  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
+  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
+  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
+  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE.
+  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
+  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
+  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
 
   DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
+  N_COMPONENTS = 3
   CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
                                          IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
+  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
   ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_R8P
-
-  FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_R4P
-
-  FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I8P
-
-  FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I4P
-
-  FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I2P
-
-  FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK2_I1P
-
-  FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_R8P
-
-  FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_R4P
-
-  FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I8P
-
-  FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I4P
-
-  FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I2P
-
-  FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF          !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE     !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK3_I1P
-
-  FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_R8P
-
-  FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_R4P
-
-  FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I8P
-
-  FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I4P
-
-  FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I2P
-
-  FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF           !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR          !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE      !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = SIZE(X, DIM=1)
-  IF (PRESENT(ONE_COMPONENT)) THEN
-    IF (ONE_COMPONENT) N_COMPONENTS = 1
-  ENDIF
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA1_RANK4_I1P
-
-  FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE.
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK1_R8P
+  ENDFUNCTION W_DATA3_RANK1_R8P
 
   FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
@@ -15829,1976 +11423,312 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
   ERROR = SELF%ERROR
   ENDFUNCTION W_DATA3_RANK1_I1P
 
-  FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+  SUBROUTINE W_DATA_APPENDED(SELF)
+  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF              !< WRITER.
+  TYPE(STRING)                              :: TAG_ATTRIBUTES    !< TAG ATTRIBUTES.
+  INTEGER(I4P)                              :: N_BYTE            !< BYTES COUNT.
+  CHARACTER(LEN=2)                          :: DATAARRAY_TYPE    !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1.
+  INTEGER(I4P)                              :: DATAARRAY_DIM     !< DATAARRAY DIMENSION.
+  REAL(R8P),    ALLOCATABLE                 :: DATAARRAY_R8P(:)  !< DATAARRAY BUFFER OF R8P.
+  REAL(R4P),    ALLOCATABLE                 :: DATAARRAY_R4P(:)  !< DATAARRAY BUFFER OF R4P.
+  INTEGER(I8P), ALLOCATABLE                 :: DATAARRAY_I8P(:)  !< DATAARRAY BUFFER OF I8P.
+  INTEGER(I4P), ALLOCATABLE                 :: DATAARRAY_I4P(:)  !< DATAARRAY BUFFER OF I4P.
+  INTEGER(I2P), ALLOCATABLE                 :: DATAARRAY_I2P(:)  !< DATAARRAY BUFFER OF I2P.
+  INTEGER(I1P), ALLOCATABLE                 :: DATAARRAY_I1P(:)  !< DATAARRAY BUFFER OF I1P.
 
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_R8P
+  CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"')
+  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_'
+  ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  DO
+    CALL READ_DATAARRAY_FROM_SCRATCH
+    IF (SELF%ERROR==0) CALL W_DATA_ON_XML
+    IF (IS_IOSTAT_END(SELF%ERROR)) EXIT
+  ENDDO
+  CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
+  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC
+  CALL SELF%WRITE_END_TAG(NAME='AppendedData')
+  CONTAINS
+    SUBROUTINE READ_DATAARRAY_FROM_SCRATCH
+    !< READ THE CURRENT DATAARAY FROM SCRATCH FILE.
 
-  FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
+    READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM
+    SELECT CASE(DATAARRAY_TYPE)
+    CASE('R8')
+      IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P
+    CASE('R4')
+      IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P
+    CASE('I8')
+      IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P
+    CASE('I4')
+      IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P
+    CASE('I2')
+      IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P
+    CASE('I1')
+      IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM))
+      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P
+    CASE DEFAULT
+      SELF%ERROR = 1
+      WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE
+      WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE))
+      WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM))
+    ENDSELECT
+    10 RETURN
+    ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH
 
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_R4P
+    SUBROUTINE W_DATA_ON_XML
+    !< WRITE THE CURRENT DATAARAY ON XML FILE.
+    CHARACTER(LEN=:), ALLOCATABLE  :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC.
 
-  FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I8P
-
-  FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I4P
-
-  FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I2P
-
-  FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 3
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA3_RANK3_I1P
-  
-  FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD "NUMBEROFCOMPONENTS" ATTRIBUTE.
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_R8P
-
-  FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_R4P
-
-  FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I8P
-
-  FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I4P
-
-  FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I2P
-
-  FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK1_I1P
-
-  FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R8P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R8P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float64'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_R8P
-
-  FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  REAL(R4P),                  INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  REAL(R4P),                  INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Float32'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_R4P
-
-  FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I8P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I8P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int64'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I8P
-
-  FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I4P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I4P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int32'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I4P
-
-  FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I2P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I2P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int16'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I2P
-
-  FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-  !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT)        :: SELF         !< WRITER.
-  CHARACTER(*),               INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-  INTEGER(I1P),               INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-  INTEGER(I1P),               INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-  LOGICAL,                    INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES".
-  INTEGER(I4P)                                     :: ERROR        !< ERROR STATUS.
-  CHARACTER(LEN=:), ALLOCATABLE                    :: DATA_TYPE    !< DATA TYPE.
-  INTEGER(I4P)                                     :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-
-  DATA_TYPE = 'Int8'
-  N_COMPONENTS = 6
-  CALL SELF%W_DATA_TAG_APPENDED(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, &
-                                         IS_TUPLES=IS_TUPLES)
-  CALL SELF%IOFFSET_UPDATE(N_BYTE=SELF%WRITE_ON_SCRATCH_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z))
-  ERROR = SELF%ERROR
-  ENDFUNCTION W_DATA6_RANK3_I1P
-
-  SUBROUTINE W_DATA_APPENDED(SELF)
-  !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF              !< WRITER.
-  TYPE(STRING)                              :: TAG_ATTRIBUTES    !< TAG ATTRIBUTES.
-  INTEGER(I4P)                              :: N_BYTE            !< BYTES COUNT.
-  CHARACTER(LEN=2)                          :: DATAARRAY_TYPE    !< DATAARRAY TYPE = R8,R4,I8,I4,I2,I1.
-  INTEGER(I4P)                              :: DATAARRAY_DIM     !< DATAARRAY DIMENSION.
-  REAL(R8P),    ALLOCATABLE                 :: DATAARRAY_R8P(:)  !< DATAARRAY BUFFER OF R8P.
-  REAL(R4P),    ALLOCATABLE                 :: DATAARRAY_R4P(:)  !< DATAARRAY BUFFER OF R4P.
-  INTEGER(I8P), ALLOCATABLE                 :: DATAARRAY_I8P(:)  !< DATAARRAY BUFFER OF I8P.
-  INTEGER(I4P), ALLOCATABLE                 :: DATAARRAY_I4P(:)  !< DATAARRAY BUFFER OF I4P.
-  INTEGER(I2P), ALLOCATABLE                 :: DATAARRAY_I2P(:)  !< DATAARRAY BUFFER OF I2P.
-  INTEGER(I1P), ALLOCATABLE                 :: DATAARRAY_I1P(:)  !< DATAARRAY BUFFER OF I1P.
-
-  CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"')
-  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_'
-  ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
-  REWIND(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
-  DO
-    CALL READ_DATAARRAY_FROM_SCRATCH
-    IF (SELF%ERROR==0) CALL W_DATA_ON_XML
-    IF (IS_IOSTAT_END(SELF%ERROR)) EXIT
-  ENDDO
-  CLOSE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
-  WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)END_REC
-  CALL SELF%WRITE_END_TAG(NAME='AppendedData')
-  CONTAINS
-    SUBROUTINE READ_DATAARRAY_FROM_SCRATCH
-    !< READ THE CURRENT DATAARAY FROM SCRATCH FILE.
-
-    READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR, END=10)N_BYTE, DATAARRAY_TYPE, DATAARRAY_DIM
-    SELECT CASE(DATAARRAY_TYPE)
-    CASE('R8')
-      IF (ALLOCATED(DATAARRAY_R8P)) DEALLOCATE(DATAARRAY_R8P) ; ALLOCATE(DATAARRAY_R8P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R8P
-    CASE('R4')
-      IF (ALLOCATED(DATAARRAY_R4P)) DEALLOCATE(DATAARRAY_R4P) ; ALLOCATE(DATAARRAY_R4P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_R4P
-    CASE('I8')
-      IF (ALLOCATED(DATAARRAY_I8P)) DEALLOCATE(DATAARRAY_I8P) ; ALLOCATE(DATAARRAY_I8P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I8P
-    CASE('I4')
-      IF (ALLOCATED(DATAARRAY_I4P)) DEALLOCATE(DATAARRAY_I4P) ; ALLOCATE(DATAARRAY_I4P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I4P
-    CASE('I2')
-      IF (ALLOCATED(DATAARRAY_I2P)) DEALLOCATE(DATAARRAY_I2P) ; ALLOCATE(DATAARRAY_I2P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I2P
-    CASE('I1')
-      IF (ALLOCATED(DATAARRAY_I1P)) DEALLOCATE(DATAARRAY_I1P) ; ALLOCATE(DATAARRAY_I1P(1:DATAARRAY_DIM))
-      READ(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)DATAARRAY_I1P
-    CASE DEFAULT
-      SELF%ERROR = 1
-      WRITE (STDERR,'(A)')' ERROR: BAD DATAARRAY_TYPE = '//DATAARRAY_TYPE
-      WRITE (STDERR,'(A)')' BYTES = '//TRIM(STR(N=N_BYTE))
-      WRITE (STDERR,'(A)')' DATAARRAY DIMENSION = '//TRIM(STR(N=DATAARRAY_DIM))
-    ENDSELECT
-    10 RETURN
-    ENDSUBROUTINE READ_DATAARRAY_FROM_SCRATCH
-
-    SUBROUTINE W_DATA_ON_XML
-    !< WRITE THE CURRENT DATAARAY ON XML FILE.
-    CHARACTER(LEN=:), ALLOCATABLE  :: CODE !< DATAARRAY ENCODED WITH BASE64 CODEC.
-
-    IF (SELF%ENCODING=='raw') THEN
-      SELECT CASE(DATAARRAY_TYPE)
-      CASE('R8')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P
-        DEALLOCATE(DATAARRAY_R8P)
-      CASE('R4')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P
-        DEALLOCATE(DATAARRAY_R4P)
-      CASE('I8')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P
-        DEALLOCATE(DATAARRAY_I8P)
-      CASE('I4')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P
-        DEALLOCATE(DATAARRAY_I4P)
-      CASE('I2')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P
-        DEALLOCATE(DATAARRAY_I2P)
-      CASE('I1')
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P
-        DEALLOCATE(DATAARRAY_I1P)
-      ENDSELECT
-    ELSE
-      SELECT CASE(DATAARRAY_TYPE)
-      CASE('R8')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      CASE('R4')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      CASE('I8')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      CASE('I4')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      CASE('I2')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      CASE('I1')
-        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P)
-        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
-      ENDSELECT
-    ENDIF
-    ENDSUBROUTINE W_DATA_ON_XML
-  ENDSUBROUTINE W_DATA_APPENDED
-
-  ! WRITE_ON_SCRATCH_DATAARRAY METHODS
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1.
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  CLASS(*),                   INTENT(IN)    :: X(1:)  !< DATA VARIABLE.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: NN     !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)
-  SELECT TYPE(X)
-  TYPE IS(REAL(R8P))
-    N_BYTE = NN*BYR8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(REAL(R4P))
-    N_BYTE = NN*BYR4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I8P))
-    N_BYTE = NN*BYI8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I4P))
-    N_BYTE = NN*BYI4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I2P))
-    N_BYTE = NN*BYI2P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I1P))
-    N_BYTE = NN*BYI1P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  ENDSELECT
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2(SELF, X) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 2.
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  CLASS(*),                   INTENT(IN)    :: X(1:,1:) !< DATA VARIABLE.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: NN       !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)
-  SELECT TYPE(X)
-  TYPE IS(REAL(R8P))
-    N_BYTE = NN*BYR8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(REAL(R4P))
-    N_BYTE = NN*BYR4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I8P))
-    N_BYTE = NN*BYI8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I4P))
-    N_BYTE = NN*BYI4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I2P))
-    N_BYTE = NN*BYI2P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I1P))
-    N_BYTE = NN*BYI1P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  ENDSELECT
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK2
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3(SELF, X) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 3.
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  CLASS(*),                   INTENT(IN)    :: X(1:,1:,1:) !< DATA VARIABLE.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: NN          !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)
-  SELECT TYPE(X)
-  TYPE IS(REAL(R8P))
-    N_BYTE = NN*BYR8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(REAL(R4P))
-    N_BYTE = NN*BYR4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I8P))
-    N_BYTE = NN*BYI8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I4P))
-    N_BYTE = NN*BYI4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I2P))
-    N_BYTE = NN*BYI2P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I1P))
-    N_BYTE = NN*BYI1P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  ENDSELECT
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK3
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4(SELF, X) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 4.
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF           !< WRITER.
-  CLASS(*),                   INTENT(IN)    :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-  INTEGER(I4P)                              :: N_BYTE         !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: NN             !< NUMBER OF ELEMENTS.
-
-  NN = SIZE(X, DIM=1)*SIZE(X, DIM=2)*SIZE(X, DIM=3)*SIZE(X, DIM=4)
-  SELECT TYPE(X)
-  TYPE IS(REAL(R8P))
-    N_BYTE = NN*BYR8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(REAL(R4P))
-    N_BYTE = NN*BYR4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I8P))
-    N_BYTE = NN*BYI8P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I4P))
-    N_BYTE = NN*BYI4P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I2P))
-    N_BYTE = NN*BYI2P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  TYPE IS(INTEGER(I1P))
-    N_BYTE = NN*BYI1P
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
-    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
-  ENDSELECT
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK4
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 2 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK2_I1P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 3 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK3_I1P
-  
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 1 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: U(1:)  !< U COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: V(1:)  !< V COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: W(1:)  !< W COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N      !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(U(N), V(N), W(N), X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK1_I1P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 2 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF     !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: U(1:,1:) !< U COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: V(1:,1:) !< V COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: W(1:,1:) !< W COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:) !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE   !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1       !< COUNTER.
-  INTEGER(I4P)                              :: N2       !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[((U(N1,N2), V(N1,N2), W(N1,N2), &
-                                                X(N1,N2), Y(N1,N2), Z(N1,N2), N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK2_I1P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  REAL(R8P),                  INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R8P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), &
-                                                  X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (R4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  REAL(R4P),                  INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  REAL(R4P),                  INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_R4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I8P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I8P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I8P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I8P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I4P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I4P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I4P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I4P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I2P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I2P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I2P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I2P
-
-  FUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P(SELF, U, V, W, X, Y, Z) RESULT(N_BYTE)
-  !< WRITE A DATAARRAY WITH 6 COMPONENTS OF RANK 3 (I1P).
-  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF        !< WRITER.
-  INTEGER(I1P),               INTENT(IN)    :: U(1:,1:,1:) !< U COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: V(1:,1:,1:) !< V COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: W(1:,1:,1:) !< W COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: X(1:,1:,1:) !< X COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Y(1:,1:,1:) !< Y COMPONENT.
-  INTEGER(I1P),               INTENT(IN)    :: Z(1:,1:,1:) !< Z COMPONENT.
-  INTEGER(I4P)                              :: N_BYTE      !< NUMBER OF BYTES
-  INTEGER(I4P)                              :: N1          !< COUNTER.
-  INTEGER(I4P)                              :: N2          !< COUNTER.
-  INTEGER(I4P)                              :: N3          !< COUNTER.
-
-  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(((U(N1,N2,N3), V(N1,N2,N3), W(N1,N2,N3), X(N1,N2,N3), Y(N1,N2,N3), Z(N1,N2,N3), &
-                                           N1=1,SIZE(X, DIM=1)),N2=1,SIZE(X, DIM=2)),N3=1,SIZE(X, DIM=3))])
-  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY6_RANK3_I1P
-ENDMODULE VTKF_FILE_XML_WRITER_APPENDED
-
-
-
-
-!< VTK FILE XML WRITER, BINARY LOCAL.
-MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL
-!< VTK FILE XML WRITER, BINARY LOCAL.
-!<
-!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION).
-!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE
-!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER)
-!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL
-!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM.
-USE PENF
-USE STRINGIFOR
-USE VTK_FORTRAN_DATAARRAY_ENCODER
-USE VTKF_FILE_XML_WRITER_ABSTRACT
-
-IMPLICIT NONE
-PRIVATE
-PUBLIC :: XML_WRITER_BINARY_LOCAL
-
-TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL
-   !< VTK FILE XML WRITER, BINARY LOCAL.
-   CONTAINS
-      ! DEFERRED METHODS
-      PROCEDURE, PASS(SELF) :: INITIALIZE                 !< INITIALIZE WRITER.
-      PROCEDURE, PASS(SELF) :: FINALIZE                   !< FINALIZE WRITER.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R8P !< WRITE DATAARRAY 1, RANK 2, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_R4P !< WRITE DATAARRAY 1, RANK 2, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I8P !< WRITE DATAARRAY 1, RANK 2, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I4P !< WRITE DATAARRAY 1, RANK 2, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I2P !< WRITE DATAARRAY 1, RANK 2, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK2_I1P !< WRITE DATAARRAY 1, RANK 2, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R8P !< WRITE DATAARRAY 1, RANK 3, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_R4P !< WRITE DATAARRAY 1, RANK 3, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I8P !< WRITE DATAARRAY 1, RANK 3, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I4P !< WRITE DATAARRAY 1, RANK 3, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I2P !< WRITE DATAARRAY 1, RANK 3, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK3_I1P !< WRITE DATAARRAY 1, RANK 3, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R8P !< WRITE DATAARRAY 1, RANK 4, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_R4P !< WRITE DATAARRAY 1, RANK 4, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I8P !< WRITE DATAARRAY 1, RANK 4, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I4P !< WRITE DATAARRAY 1, RANK 4, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I2P !< WRITE DATAARRAY 1, RANK 4, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA1_RANK4_I1P !< WRITE DATAARRAY 1, RANK 4, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R8P !< WRITE DATAARRAY 3, RANK 3, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_R4P !< WRITE DATAARRAY 3, RANK 3, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I8P !< WRITE DATAARRAY 3, RANK 3, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I4P !< WRITE DATAARRAY 3, RANK 3, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I2P !< WRITE DATAARRAY 3, RANK 3, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA3_RANK3_I1P !< WRITE DATAARRAY 3, RANK 3, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R8P !< WRITE DATAARRAY 6, RANK 1, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_R4P !< WRITE DATAARRAY 6, RANK 1, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I8P !< WRITE DATAARRAY 6, RANK 1, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I4P !< WRITE DATAARRAY 6, RANK 1, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I2P !< WRITE DATAARRAY 6, RANK 1, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK1_I1P !< WRITE DATAARRAY 6, RANK 1, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R8P !< WRITE DATAARRAY 6, RANK 3, R8P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_R4P !< WRITE DATAARRAY 6, RANK 3, R4P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I8P !< WRITE DATAARRAY 6, RANK 3, I8P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I4P !< WRITE DATAARRAY 6, RANK 3, I4P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I2P !< WRITE DATAARRAY 6, RANK 3, I2P.
-      PROCEDURE, PASS(SELF) :: W_DATA6_RANK3_I1P !< WRITE DATAARRAY 6, RANK 3, I1P.
-      PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
-ENDTYPE XML_WRITER_BINARY_LOCAL
-CONTAINS
-   FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
-                       IS_VOLATILE, MESH_KIND) RESULT(ERROR)
-   !< INITIALIZE WRITER.
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: FORMAT        !< FILE FORMAT: BINARY.
-   CHARACTER(*),                   INTENT(IN)           :: FILENAME      !< FILE NAME.
-   CHARACTER(*),                   INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
-   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
-   CHARACTER(*),                   INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-
-   SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE
-   SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
-   SELF%FORMAT_CH = FORMAT
-   SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER()
-   CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME)
-   CALL SELF%WRITE_HEADER_TAG
-   CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
-   ERROR = SELF%ERROR
-   ENDFUNCTION INITIALIZE
-
-   FUNCTION FINALIZE(SELF) RESULT(ERROR)
-   !< FINALIZE WRITER.
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF  !< WRITER.
-   INTEGER(I4P)                                  :: ERROR !< ERROR STATUS.
-
-   CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS())
-   CALL SELF%WRITE_END_TAG(NAME='VTKFile')
-   CALL SELF%CLOSE_XML_FILE
-   ERROR = SELF%ERROR
-   ENDFUNCTION FINALIZE
-
-   ! W_DATA METHODS
-   FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_R8P
-
-   FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_R4P
-
-   FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_I8P
-
-   FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_I4P
-
-   FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_I2P
-
-   FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = 1
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK1_I1P
-
-   FUNCTION W_DATA1_RANK2_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_R8P
-
-   FUNCTION W_DATA1_RANK2_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_R4P
-
-   FUNCTION W_DATA1_RANK2_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_I8P
-
-   FUNCTION W_DATA1_RANK2_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_I4P
-
-   FUNCTION W_DATA1_RANK2_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_I2P
-
-   FUNCTION W_DATA1_RANK2_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:)      !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK2_I1P
-
-   FUNCTION W_DATA1_RANK3_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_R8P
-
-   FUNCTION W_DATA1_RANK3_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_R4P
-
-   FUNCTION W_DATA1_RANK3_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_I8P
-
-   FUNCTION W_DATA1_RANK3_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+    IF (SELF%ENCODING=='raw') THEN
+      SELECT CASE(DATAARRAY_TYPE)
+      CASE('R8')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R8P
+        DEALLOCATE(DATAARRAY_R8P)
+      CASE('R4')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_R4P
+        DEALLOCATE(DATAARRAY_R4P)
+      CASE('I8')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I8P
+        DEALLOCATE(DATAARRAY_I8P)
+      CASE('I4')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I4P
+        DEALLOCATE(DATAARRAY_I4P)
+      CASE('I2')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I2P
+        DEALLOCATE(DATAARRAY_I2P)
+      CASE('I1')
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)N_BYTE, DATAARRAY_I1P
+        DEALLOCATE(DATAARRAY_I1P)
+      ENDSELECT
+    ELSE
+      SELECT CASE(DATAARRAY_TYPE)
+      CASE('R8')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R8P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('R4')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_R4P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I8')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I8P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I4')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I4P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I2')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I2P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      CASE('I1')
+        CODE = ENCODE_BINARY_DATAARRAY(X=DATAARRAY_I1P)
+        WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)CODE
+      ENDSELECT
+    ENDIF
+    ENDSUBROUTINE W_DATA_ON_XML
+  ENDSUBROUTINE W_DATA_APPENDED
 
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_I4P
+  ! WRITE_ON_SCRATCH_DATAARRAY METHODS
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1(SELF, X) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 1 COMPONENTS OF RANK 1.
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  CLASS(*),                   INTENT(IN)    :: X(1:)  !< DATA VARIABLE.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: NN     !< NUMBER OF ELEMENTS.
 
-   FUNCTION W_DATA1_RANK3_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                  INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I2P),                  INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                       INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                       INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                       :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                        :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                       :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  NN = SIZE(X, DIM=1)
+  SELECT TYPE(X)
+  TYPE IS(REAL(R8P))
+    N_BYTE = NN*BYR8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(REAL(R4P))
+    N_BYTE = NN*BYR4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'R4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I8P))
+    N_BYTE = NN*BYI8P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I8', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I4P))
+    N_BYTE = NN*BYI4P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I4', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I2P))
+    N_BYTE = NN*BYI2P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I2', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  TYPE IS(INTEGER(I1P))
+    N_BYTE = NN*BYI1P
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)N_BYTE, 'I1', NN
+    WRITE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)X
+  ENDSELECT
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY1_RANK1
 
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_I2P
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R8P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R8P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   FUNCTION W_DATA1_RANK3_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME     !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)   !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES     !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE     !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS  !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE          !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R8P
 
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK3_I1P
-
-   FUNCTION W_DATA1_RANK4_R8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (R4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  REAL(R4P),                  INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  REAL(R4P),                  INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_R8P
-
-   FUNCTION W_DATA1_RANK4_R4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_R4P
 
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_R4P
-
-   FUNCTION W_DATA1_RANK4_I8P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I8P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I8P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I8P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_I8P
-
-   FUNCTION W_DATA1_RANK4_I4P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I8P
 
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_I4P
-
-   FUNCTION W_DATA1_RANK4_I2P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I4P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I4P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I4P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_I2P
-
-   FUNCTION W_DATA1_RANK4_I1P(SELF, DATA_NAME, X, ONE_COMPONENT, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="N"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF           !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME      !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:,1:) !< DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: ONE_COMPONENT  !< FORCE ONE COMPONENT.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES      !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR          !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE      !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS   !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE           !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I4P
 
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = SIZE(X, DIM=1)
-   IF (PRESENT(ONE_COMPONENT)) THEN
-     IF (ONE_COMPONENT) N_COMPONENTS = 1
-   ENDIF
-   CODE = ENCODE_BINARY_DATAARRAY(X=X)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA1_RANK4_I1P
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I2P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I2P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I2P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I2P
 
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_R8P
+  FUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P(SELF, X, Y, Z) RESULT(N_BYTE)
+  !< WRITE A DATAARRAY WITH 3 COMPONENTS OF RANK 1 (I1P).
+  CLASS(XML_WRITER_APPENDED), INTENT(INOUT) :: SELF   !< WRITER.
+  INTEGER(I1P),               INTENT(IN)    :: X(1:)  !< X COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Y(1:)  !< Y COMPONENT.
+  INTEGER(I1P),               INTENT(IN)    :: Z(1:)  !< Z COMPONENT.
+  INTEGER(I4P)                              :: N_BYTE !< NUMBER OF BYTES
+  INTEGER(I4P)                              :: N      !< COUNTER.
 
-   FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+  N_BYTE = SELF%WRITE_ON_SCRATCH_DATAARRAY(X=[(X(N), Y(N), Z(N), N=1,SIZE(X, DIM=1))])
+  ENDFUNCTION WRITE_ON_SCRATCH_DATAARRAY3_RANK1_I1P
+  
+ENDMODULE VTKF_FILE_XML_WRITER_APPENDED
 
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_R4P
 
-   FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_I8P
 
-   FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+!< VTK FILE XML WRITER, BINARY LOCAL.
+MODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL
+!< VTK FILE XML WRITER, BINARY LOCAL.
+!<
+!< THIS WRITER IS (CURRENTLY) THE ONLY ONE ABLE ALSO TO CREATE A *VOLATILE* FILE (ENABLING VOLATILE OPTION).
+!< INSTEAD OF SAVING DATA INTO A REAL FILE ON THE SYSTEM, THIS WRITER CAN SAVE DATA INTO A (VOLATILE) CHARACTERS STRING THAT CAN BE
+!< USED ALSO ON (SLAVE) PROCESSES THAT HAVE NOT ACCESS TO FILESYSTEM: THE VOLATILE STRING CAN BE EASILY SENT TO OTHER (MASTER)
+!< PROCESSES HAVING ACCESS TO FILESYTEM. THE VOLATILE WRITER MODE IS DESIGNED TO FACILITATE THE USE OF THE LIBRARY IN PARALLEL
+!< ENVINROMENTS WEHERE NOT ALL PROCESSES/THREADS HAVE ACCESS TO FILESYSTEM.
+USE PENF
+USE STRINGIFOR
+USE VTK_FORTRAN_DATAARRAY_ENCODER
+USE VTKF_FILE_XML_WRITER_ABSTRACT
 
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_I4P
+IMPLICIT NONE
+PRIVATE
+PUBLIC :: XML_WRITER_BINARY_LOCAL
 
-   FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+TYPE, EXTENDS(XML_WRITER_ABSTRACT) :: XML_WRITER_BINARY_LOCAL
+   !< VTK FILE XML WRITER, BINARY LOCAL.
+   CONTAINS
+      ! DEFERRED METHODS
+      PROCEDURE, PASS(SELF) :: INITIALIZE                 !< INITIALIZE WRITER.
+      PROCEDURE, PASS(SELF) :: FINALIZE                   !< FINALIZE WRITER.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R8P !< WRITE DATAARRAY 1, RANK 1, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_R4P !< WRITE DATAARRAY 1, RANK 1, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I8P !< WRITE DATAARRAY 1, RANK 1, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I4P !< WRITE DATAARRAY 1, RANK 1, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I2P !< WRITE DATAARRAY 1, RANK 1, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA1_RANK1_I1P !< WRITE DATAARRAY 1, RANK 1, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R8P !< WRITE DATAARRAY 3, RANK 1, R8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_R4P !< WRITE DATAARRAY 3, RANK 1, R4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I8P !< WRITE DATAARRAY 3, RANK 1, I8P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I4P !< WRITE DATAARRAY 3, RANK 1, I4P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I2P !< WRITE DATAARRAY 3, RANK 1, I2P.
+      PROCEDURE, PASS(SELF) :: W_DATA3_RANK1_I1P !< WRITE DATAARRAY 3, RANK 1, I1P.
+      PROCEDURE, PASS(SELF) :: W_DATA_APPENDED   !< WRITE APPENDED.
+ENDTYPE XML_WRITER_BINARY_LOCAL
+CONTAINS
+   FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, NZ1, NZ2, &
+                       IS_VOLATILE, MESH_KIND) RESULT(ERROR)
+   !< INITIALIZE WRITER.
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF          !< WRITER.
+   CHARACTER(*),                   INTENT(IN)           :: FORMAT        !< FILE FORMAT: BINARY.
+   CHARACTER(*),                   INTENT(IN)           :: FILENAME      !< FILE NAME.
+   CHARACTER(*),                   INTENT(IN)           :: MESH_TOPOLOGY !< MESH TOPOLOGY.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX1           !< INITIAL NODE OF X AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NX2           !< FINAL NODE OF X AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY1           !< INITIAL NODE OF Y AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NY2           !< FINAL NODE OF Y AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ1           !< INITIAL NODE OF Z AXIS.
+   INTEGER(I4P),                   INTENT(IN), OPTIONAL :: NZ2           !< FINAL NODE OF Z AXIS.
+   CHARACTER(*),                   INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
+   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
+   INTEGER(I4P)                                         :: ERROR         !< ERROR STATUS.
 
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
+   SELF%IS_VOLATILE = .FALSE. ; IF (PRESENT(IS_VOLATILE)) SELF%IS_VOLATILE = IS_VOLATILE
+   SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
+   SELF%FORMAT_CH = FORMAT
+   SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER()
+   CALL SELF%OPEN_XML_FILE(FILENAME=FILENAME)
+   CALL SELF%WRITE_HEADER_TAG
+   CALL SELF%WRITE_TOPOLOGY_TAG(NX1=NX1, NX2=NX2, NY1=NY1, NY2=NY2, NZ1=NZ1, NZ2=NZ2, MESH_KIND=MESH_KIND)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_I2P
+   ENDFUNCTION INITIALIZE
 
-   FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
+   FUNCTION FINALIZE(SELF) RESULT(ERROR)
+   !< FINALIZE WRITER.
+   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF  !< WRITER.
+   INTEGER(I4P)                                  :: ERROR !< ERROR STATUS.
 
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
+   CALL SELF%WRITE_END_TAG(NAME=SELF%TOPOLOGY%CHARS())
+   CALL SELF%WRITE_END_TAG(NAME='VTKFile')
+   CALL SELF%CLOSE_XML_FILE
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK1_I1P
+   ENDFUNCTION FINALIZE
 
-   FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
+   ! W_DATA METHODS
+   FUNCTION W_DATA1_RANK1_R8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R8P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   REAL(R8P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17806,20 +11736,18 @@ FUNCTION W_DATA3_RANK3_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Float64'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_R8P
+   ENDFUNCTION W_DATA1_RANK1_R8P
 
-   FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
+   FUNCTION W_DATA1_RANK1_R4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (R4P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   REAL(R4P),                      INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17827,20 +11755,18 @@ FUNCTION W_DATA3_RANK3_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Float32'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_R4P
+   ENDFUNCTION W_DATA1_RANK1_R4P
 
-   FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
+   FUNCTION W_DATA1_RANK1_I8P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I8P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17848,20 +11774,18 @@ FUNCTION W_DATA3_RANK3_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int64'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_I8P
+   ENDFUNCTION W_DATA1_RANK1_I8P
 
-   FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
+   FUNCTION W_DATA1_RANK1_I4P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I4P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17869,20 +11793,18 @@ FUNCTION W_DATA3_RANK3_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int32'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_I4P
+   ENDFUNCTION W_DATA1_RANK1_I4P
 
-   FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
+   FUNCTION W_DATA1_RANK1_I2P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I2P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17890,20 +11812,18 @@ FUNCTION W_DATA3_RANK3_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int16'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_I2P
+   ENDFUNCTION W_DATA1_RANK1_I2P
 
-   FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
+   FUNCTION W_DATA1_RANK1_I1P(SELF, DATA_NAME, X, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="1"...>...</DATAARRAY>` TAG (I1P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
+   INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< DATA VARIABLE.
    LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
    INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
    CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
@@ -17911,20 +11831,17 @@ FUNCTION W_DATA3_RANK3_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int8'
-   N_COMPONENTS = 3
-   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 1
+   CODE = ENCODE_BINARY_DATAARRAY(X=X)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA3_RANK3_I1P
-   
-   FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="6"...>...</DATAARRAY>` TAG (R8P).
+   ENDFUNCTION W_DATA1_RANK1_I1P
+
+   FUNCTION W_DATA3_RANK1_R8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    REAL(R8P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    REAL(R8P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    REAL(R8P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -17935,20 +11852,17 @@ FUNCTION W_DATA6_RANK1_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Float64'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_R8P
+   ENDFUNCTION W_DATA3_RANK1_R8P
 
-   FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   FUNCTION W_DATA3_RANK1_R4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    REAL(R4P),                      INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    REAL(R4P),                      INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    REAL(R4P),                      INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -17959,20 +11873,17 @@ FUNCTION W_DATA6_RANK1_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Float32'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_R4P
+   ENDFUNCTION W_DATA3_RANK1_R4P
 
-   FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   FUNCTION W_DATA3_RANK1_I8P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    INTEGER(I8P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    INTEGER(I8P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    INTEGER(I8P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -17983,20 +11894,17 @@ FUNCTION W_DATA6_RANK1_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int64'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_I8P
+   ENDFUNCTION W_DATA3_RANK1_I8P
 
-   FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   FUNCTION W_DATA3_RANK1_I4P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    INTEGER(I4P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    INTEGER(I4P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    INTEGER(I4P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -18007,20 +11915,17 @@ FUNCTION W_DATA6_RANK1_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int32'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_I4P
+   ENDFUNCTION W_DATA3_RANK1_I4P
 
-   FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   FUNCTION W_DATA3_RANK1_I2P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    INTEGER(I2P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    INTEGER(I2P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    INTEGER(I2P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -18031,20 +11936,17 @@ FUNCTION W_DATA6_RANK1_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int16'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_I2P
+   ENDFUNCTION W_DATA3_RANK1_I2P
 
-   FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
+   FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
    CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: U(1:)        !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: V(1:)        !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: W(1:)        !< W COMPONENT OF DATA VARIABLE.
    INTEGER(I1P),                   INTENT(IN)           :: X(1:)        !< X COMPONENT OF DATA VARIABLE.
    INTEGER(I1P),                   INTENT(IN)           :: Y(1:)        !< Y COMPONENT OF DATA VARIABLE.
    INTEGER(I1P),                   INTENT(IN)           :: Z(1:)        !< Z COMPONENT OF DATA VARIABLE.
@@ -18055,157 +11957,13 @@ FUNCTION W_DATA6_RANK1_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(
    CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
 
    DATA_TYPE = 'Int8'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK1_I1P
-
-   FUNCTION W_DATA6_RANK3_R8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R8P),                      INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R8P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float64'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_R8P
-
-   FUNCTION W_DATA6_RANK3_R4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (R4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   REAL(R4P),                      INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   REAL(R4P),                      INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Float32'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_R4P
-
-   FUNCTION W_DATA6_RANK3_I8P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I8P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I8P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I8P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int64'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_I8P
-
-   FUNCTION W_DATA6_RANK3_I4P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I4P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I4P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I4P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int32'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_I4P
-
-   FUNCTION W_DATA6_RANK3_I2P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I2P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I2P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I2P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int16'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
-   CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
-                                 IS_TUPLES=IS_TUPLES)
-   ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_I2P
-
-   FUNCTION W_DATA6_RANK3_I1P(SELF, DATA_NAME, U, V, W, X, Y, Z, IS_TUPLES) RESULT(ERROR)
-   !< WRITE `<DATAARRAY... NumberOfComponents="3"...>...</DATAARRAY>` TAG (I1P).
-   CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT)        :: SELF         !< WRITER.
-   CHARACTER(*),                   INTENT(IN)           :: DATA_NAME    !< DATA NAME.
-   INTEGER(I1P),                   INTENT(IN)           :: U(1:,1:,1:)  !< U COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: V(1:,1:,1:)  !< V COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: W(1:,1:,1:)  !< W COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: X(1:,1:,1:)  !< X COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Y(1:,1:,1:)  !< Y COMPONENT OF DATA VARIABLE.
-   INTEGER(I1P),                   INTENT(IN)           :: Z(1:,1:,1:)  !< Z COMPONENT OF DATA VARIABLE.
-   LOGICAL,                        INTENT(IN), OPTIONAL :: IS_TUPLES    !< USE "NUMBEROFTUPLES" INSTEAD OF "NUMBEROFCOMPONENTS".
-   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: DATA_TYPE    !< DATA TYPE.
-   INTEGER(I4P)                                         :: N_COMPONENTS !< NUMBER OF COMPONENTS.
-   CHARACTER(LEN=:), ALLOCATABLE                        :: CODE         !< DATA VARIABLE ENCODED, BINARY OR BASE64 CODEC.
-
-   DATA_TYPE = 'Int8'
-   N_COMPONENTS = 6
-   CODE = ENCODE_BINARY_DATAARRAY(U=U, V=V, W=W, X=X, Y=Y, Z=Z)
+   N_COMPONENTS = 3
+   CODE = ENCODE_BINARY_DATAARRAY(X=X, Y=Y, Z=Z)
    CALL SELF%W_DATA_TAG(DATA_TYPE=DATA_TYPE, NUMBER_OF_COMPONENTS=N_COMPONENTS, DATA_NAME=DATA_NAME, DATA_CONTENT=CODE, &
                                  IS_TUPLES=IS_TUPLES)
    ERROR = SELF%ERROR
-   ENDFUNCTION W_DATA6_RANK3_I1P
-
+   ENDFUNCTION W_DATA3_RANK1_I1P
+   
    SUBROUTINE W_DATA_APPENDED(SELF)
    !< DO NOTHING, BINARY LOCAL IS NOT APPENDED.
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
@@ -18617,28 +12375,7 @@ MODULE VTK_FORTRAN
 PUBLIC :: PVTK_FILE
 PUBLIC :: VTK_FILE
 PUBLIC :: VTM_FILE
-PUBLIC :: WRITE_XML_VOLATILE
 
-CONTAINS
-   FUNCTION WRITE_XML_VOLATILE(XML_VOLATILE, FILENAME) RESULT(ERROR)
-   !< WRITE THE VOLATILE FILE INTO A REAL FILE.
-   !< THIS IS WHAT A MASTER PROCESS SHOULD DO INTO A PARALLEL SCENARIO WHERE IT BEING THE ONLY PROCESS ALLOWED TO ACCESS TO
-   !< FILESYSTEM: SLAVE PROCESSES CREATE XML VOLATILE FILE ECONDED INTO A CHARACTERS STRING AND MASTER PROCESS COLLECTS AND WRITES
-   !< THEM BY MEANS OF `WRITE_XML_VOLATILE`.
-   CHARACTER(*), INTENT(IN) :: XML_VOLATILE !< XML VOLATILE FILE.
-   CHARACTER(*), INTENT(IN) :: FILENAME     !< XML FILE NAME.
-   INTEGER(I4P)             :: ERROR        !< STATUS ERROR.
-   INTEGER(I4P)             :: XML_UNIT     !< XML FILE UNIT.
-
-   OPEN(NEWUNIT=XML_UNIT,             &
-        FILE=TRIM(ADJUSTL(FILENAME)), &
-        FORM='UNFORMATTED',           &
-        ACCESS='STREAM',              &
-        ACTION='WRITE',               &
-        STATUS='REPLACE',             &
-        IOSTAT=ERROR)
-   WRITE(UNIT=XML_UNIT, IOSTAT=ERROR) XML_VOLATILE
-   ENDFUNCTION WRITE_XML_VOLATILE
 ENDMODULE VTK_FORTRAN
 
 
@@ -18682,90 +12419,12 @@ MODULE VTK_FDS_INTERFACE
 IMPLICIT NONE (TYPE,EXTERNAL)
 PRIVATE
 
-PUBLIC WRITE_VTK_SLICE_WRAPPER,BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
+PUBLIC BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
        WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
        DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 
 CONTAINS
 
-SUBROUTINE WRITE_VTK_SLICE_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
-INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
-REAL(EB), INTENT(IN) :: T
-TYPE (SLICE_TYPE), POINTER :: SL
-INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
-REAL(FB) :: STIME
-REAL(EB) :: TT
-CHARACTER(200) :: TMP_FILE
-
-! Generate filename
-STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
-TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
-ITM  = INT(TT)
-ITM1 = NINT(ABS(TT-ITM)*100)
-IF (ITM1==100) THEN
-   ITM = ITM+1
-   ITM1 = 0
-ENDIF
-WRITE(FN_SL3D_VTK(NMESHES+1),'(A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_SL3D_',ITM,ITM1,'.pvtu'
-
-! First part of header before quantities
-OPEN(LU_SL3D_VTK(NMESHES+1),FILE=FN_SL3D_VTK(NMESHES+1),FORM='FORMATTED')
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '<?xml version="1.0"?>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') &
-   '<VTKFile type="',TRIM(MESH_TOPOLOGY),'" version="1.0" byte_order="LittleEndian">'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  <',TRIM(MESH_TOPOLOGY),' GhostLevel="0">'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPointData>'
-
-! Add PointData arrays
-NQT = MESHES(1)%N_SLCF
-QUANTITY_LOOP2: DO IQ=1,NQT
-   SL => SLICE(IQ)
-   I1  = SL%I1
-   I2  = SL%I2
-   J1  = SL%J1
-   J2  = SL%J2
-   K1  = SL%K1
-   K2  = SL%K2
-   IF (I2-I1==0 .OR. J2-J1==0 .OR. K2-K1==0) CYCLE QUANTITY_LOOP2
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="1" Name='
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='NO') '"',TRIM(SL%SMOKEVIEW_LABEL(1:30)),'" format='
-   IF (VTK_BINARY) THEN
-      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-   ELSE
-      WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-   ENDIF
-ENDDO QUANTITY_LOOP2
-
-! Close PointData
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPointData>'
-
-! Add Point arrays
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PPoints>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='NO') '      <PDataArray type="Float32" NumberOfComponents="3" Name="Points" format='
-IF (VTK_BINARY) THEN
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"binary"/>'
-ELSE
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '"ascii"/>'
-ENDIF
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    </PPoints>'
-
-! Add CellData
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '    <PCellData></PCellData>'
-
-! Write pieces
-DO I=1,NMESHES
-   WRITE(TMP_FILE,'(A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_SL3D_',I,'_',ITM,ITM1,'.vtu'
-   WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '    <Piece Source="',TRIM(TMP_FILE),'"/>'
-ENDDO
-
-! Finalize file
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A,A,A)',ADVANCE='YES') '  </',TRIM(MESH_TOPOLOGY),'>'
-WRITE(LU_SL3D_VTK(NMESHES+1),'(A)',ADVANCE='YES') '</VTKFile>'
-CLOSE(LU_SL3D_VTK(NMESHES+1))
-END SUBROUTINE WRITE_VTK_SLICE_WRAPPER
-
-
 
 SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
 INTEGER, INTENT(IN) :: NMESHES

From 6740a6a24b665b37fd48663ae62b7b4d88dc2592 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 15:07:23 -0500
Subject: [PATCH 28/31] add -ipo optimization back in for impi_intel_linux

---
 Build/makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Build/makefile b/Build/makefile
index 8f7de5a076e..7e3a86551a6 100644
--- a/Build/makefile
+++ b/Build/makefile
@@ -233,7 +233,7 @@ impi_intel_win_openmp_db : setup_win $(objwin_mpi)
 
 # Linux Intel Fortran Compiler and Intel MPI
 
-impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2  -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT
+impi_intel_linux : FFLAGS = -m64 -fc=$(I_IFORT) -O2 -ipo -no-wrap-margin $(GITINFO) $(INTELMPI_COMPINFO) $(FFLAGSMKL_INTEL) -DUSE_IFPORT
 impi_intel_linux : LFLAGSMKL = $(LFLAGSMKL_INTEL)
 impi_intel_linux : FCOMPL = mpiifort
 impi_intel_linux : obj = fds_impi_intel_linux

From f3148578f68743a4980024b18cdee79a3ee77668 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Sat, 6 Jan 2024 16:01:22 -0500
Subject: [PATCH 29/31] clean up unused variables for debug compilation

---
 Source/dump.f90 | 19 +++++------
 Source/vtkf.f90 | 90 +++++++++++++++++++++++++++++++++++--------------
 2 files changed, 72 insertions(+), 37 deletions(-)

diff --git a/Source/dump.f90 b/Source/dump.f90
index adfa36ee1ab..79173bab976 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -21,7 +21,7 @@ MODULE DUMP
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
 USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
                 WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
-				DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
+                DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
 IMPLICIT NONE (TYPE,EXTERNAL)
@@ -137,7 +137,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ! VTK 3-D slices
 IF (T>=SL3D_VTK_CLOCK(SL3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
    IF (NM .EQ. 1) THEN
-      CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+      CALL WRITE_VTK_SL3D_WRAPPER(T,NMESHES)
    ENDIF
    CALL DUMP_SLCF(T,DT,NM,3)
    DO WHILE(SL3D_VTK_COUNTER(NM)<SIZE(SL3D_VTK_CLOCK)-1)
@@ -149,7 +149,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ! VTK Smoke 3D slices
 IF (T>=SM3D_VTK_CLOCK(SM3D_VTK_COUNTER(NM)) .OR. STOP_STATUS==INSTABILITY_STOP) THEN
    IF (NM .EQ. 1) THEN
-      CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+      CALL WRITE_VTK_SM3D_WRAPPER(T,NMESHES)
    ENDIF
    CALL DUMP_SMOKE3D(T,DT,NM,1)
    DO WHILE(SM3D_VTK_COUNTER(NM)<SIZE(SM3D_VTK_CLOCK)-1)
@@ -162,7 +162,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 
 IF (T>=BNDF_VTK_CLOCK(BNDF_VTK_COUNTER(NM))) THEN
    IF (NM .EQ. 1) THEN
-      CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES,'PUnstructuredGrid')
+      CALL WRITE_VTK_BNDF_WRAPPER(T,NMESHES)
    ENDIF
    CALL DUMP_BNDF(T,DT,NM,1)
    DO WHILE(BNDF_VTK_COUNTER(NM)<SIZE(BNDF_VTK_CLOCK)-1)
@@ -4314,7 +4314,6 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
 !INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK_INT
-CHARACTER(C_CHAR) :: C, MOLD
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
@@ -4424,8 +4423,7 @@ SUBROUTINE DUMP_SMOKE3D(T,DT,NM,IFRMT)
          ELSE
             VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SMOKE3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
          ENDIF ! do not change capitalization on mesh topology
-         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', &
-                                           NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+         CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
          VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
@@ -6132,8 +6130,7 @@ SUBROUTINE DUMP_SLCF(T,DT,NM,IFRMT)
       ELSE
          VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_SL3D_VTK(NM), MESH_TOPOLOGY='UnstructuredGrid')
       ENDIF ! do not change capitalization on mesh topology
-      CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, 'UnstructuredGrid', &
-                                        NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
+      CALL BUILD_VTK_GAS_PHASE_GEOMETRY(NM, NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NP, NC=NC)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NP, NC=NC, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_CONNECTIVITY(NC=NC, CONNECTIVITY=CONNECT, OFFSET=OFFSETS, VTKC_TYPE=VTKC_TYPE)
@@ -10775,7 +10772,7 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
 TYPE(PATCH_TYPE), POINTER :: PA
 REAL(FB) BNDF_TIME, BNDF_VAL_MIN, BNDF_VAL_MAX
 INTEGER :: CHANGE_BOUND, IERROR
-INTEGER :: NX, NY, NZ, NCELLS, NPOINTS
+INTEGER :: NCELLS, NPOINTS
 INTEGER, ALLOCATABLE, DIMENSION(:) :: LOCATIONS,FACES,SURFIND,GEOMIND
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: VALS, VERTS
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: QQ_PACK
@@ -10997,7 +10994,7 @@ SUBROUTINE DUMP_BNDF(T,DT,NM,IFRMT)
    PATCH_LOOP1: DO IP=1,N_PATCH
       PA => PATCH(IP)
       ! Initialize piece
-      CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, 'UnstructuredGrid', NCELLS, NPOINTS, &
+      CALL BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, NCELLS, NPOINTS, &
                                           X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)          
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPOINTS, NC=NCELLS)
       VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPOINTS, NC=NCELLS, X=X_PTS, Y=Y_PTS, Z=Z_PTS)
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 74db6a9bdc6..a8bb8d9a407 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -5955,6 +5955,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I1P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_INTEGER_I1P
 
 #ifndef _NVF
@@ -5979,6 +5981,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I2P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_INTEGER_I2P
 #endif
 
@@ -6003,6 +6007,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I4P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_INTEGER_I4P
 
    ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER)
@@ -6026,6 +6032,8 @@ ELEMENTAL FUNCTION TO_INTEGER_I8P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_INTEGER()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_INTEGER_I8P
 
    ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER)
@@ -6049,6 +6057,8 @@ ELEMENTAL FUNCTION TO_REAL_R4P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_REAL_R4P
 
    ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER)
@@ -6072,6 +6082,8 @@ ELEMENTAL FUNCTION TO_REAL_R8P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_REAL_R8P
 
    ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER)
@@ -6095,6 +6107,8 @@ ELEMENTAL FUNCTION TO_REAL_R16P(SELF, KIND) RESULT(TO_NUMBER)
    IF (ALLOCATED(SELF%RAW)) THEN
      IF (SELF%IS_REAL()) READ(SELF%RAW, *) TO_NUMBER
    ENDIF
+   IF (KIND.EQ.-1) THEN
+   ENDIF
    ENDFUNCTION TO_REAL_R16P
 
    ELEMENTAL FUNCTION UNESCAPE(SELF, TO_UNESCAPE, UNESC) RESULT(UNESCAPED)
@@ -7520,7 +7534,8 @@ SUBROUTINE READ_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG)
    CHARACTER(LEN=LEN(IOMSG))                :: LOCAL_IOMSG !< LOCAL VARIANT OF IOMSG, SO IT DOESN'T GET INAPPROPRIATELY REDEFINED.
    CHARACTER(KIND=CK, LEN=1)                :: DELIM       !< STRING DELIMITER, IF ANY.
    CHARACTER(KIND=CK, LEN=100)              :: TEMPORARY   !< TEMPORARY STORAGE STRING.
-
+   IF (V_LIST(1).EQ.0) THEN
+   ENDIF
    IF (IOTYPE == 'LISTDIRECTED') THEN
       CALL GET_NEXT_NON_BLANK_CHARACTER_ANY_RECORD(UNIT=UNIT, CH=DELIM, IOSTAT=IOSTAT, IOMSG=IOMSG)
       IF (IOSTAT/=0) RETURN
@@ -7654,7 +7669,10 @@ SUBROUTINE WRITE_FORMATTED(DTV, UNIT, IOTYPE, V_LIST, IOSTAT, IOMSG)
    INTEGER,                   INTENT(IN)    :: V_LIST(:) !< EDIT DESCRIPTOR LIST.
    INTEGER,                   INTENT(OUT)   :: IOSTAT    !< IO STATUS CODE.
    CHARACTER(KIND=CK, LEN=*), INTENT(INOUT) :: IOMSG     !< IO STATUS MESSAGE.
-
+   IF (IOTYPE=="") THEN
+   ENDIF
+   IF (V_LIST(1).EQ.0) THEN
+   ENDIF
    IF (ALLOCATED(DTV%RAW)) THEN
      WRITE(UNIT, "(A)", IOSTAT=IOSTAT, IOMSG=IOMSG)DTV%RAW
    ELSE
@@ -8792,6 +8810,8 @@ ELEMENTAL SUBROUTINE SEARCH(SELF, TAG_NAME, SOURCE, TSTART, TEND)
   INTEGER(I4P)                          :: TEND_C   !< STARTING INDEX OF TAG INSIDE THE CURRENT SLICE OF SOURCE.
   INTEGER(I4P)                          :: I
 
+  IF (I.EQ.-1) THEN
+  ENDIF
   CALL SELF%FREE
   SELF%TAG_NAME = TAG_NAME
   TSTART_ = 1
@@ -9478,10 +9498,11 @@ SUBROUTINE OPEN_XML_FILE(SELF, FILENAME)
    ENDIF
    ENDSUBROUTINE OPEN_XML_FILE
 
-   ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
+   ELEMENTAL SUBROUTINE FREE(SELF)
+   !ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
    !< FREE ALLOCATED MEMORY.
    CLASS(XML_WRITER_ABSTRACT), INTENT(INOUT)         :: SELF  !< WRITER.
-   INTEGER(I4P),               INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS.
+   !INTEGER(I4P),               INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS.
 
    CALL SELF%FORMAT_CH%FREE
    CALL SELF%TOPOLOGY%FREE
@@ -9495,11 +9516,12 @@ ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
    CALL SELF%XML_VOLATILE%FREE
    ENDSUBROUTINE FREE
 
-   PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR)
+   PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE)
+   !PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR)
    !< RETURN THE EVENTUAL XML VOLATILE STRING FILE.
    CLASS(XML_WRITER_ABSTRACT), INTENT(IN)               :: SELF         !< WRITER.
    CHARACTER(LEN=:),           INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE.
-   INTEGER(I4P),               INTENT(OUT), OPTIONAL    :: ERROR        !< ERROR STATUS.
+   !INTEGER(I4P),               INTENT(OUT), OPTIONAL    :: ERROR        !< ERROR STATUS.
 
    IF (SELF%IS_VOLATILE) THEN
       XML_VOLATILE = SELF%XML_VOLATILE%RAW
@@ -9923,6 +9945,8 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
       SELF%ERROR = 1
       RETURN
    ENDIF
+   IF (NC.EQ.-1) THEN
+   ENDIF
    CALL SELF%WRITE_START_TAG(NAME='Points')
    ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
    CALL SELF%WRITE_END_TAG(NAME='Points')
@@ -9943,6 +9967,8 @@ FUNCTION WRITE_GEO_UNST_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
       SELF%ERROR = 1
       RETURN
    ENDIF
+   IF (NC.EQ.-1) THEN
+   ENDIF
    CALL SELF%WRITE_START_TAG(NAME='Points')
    ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
    CALL SELF%WRITE_END_TAG(NAME='Points')
@@ -9964,6 +9990,8 @@ FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R8P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
       SELF%ERROR = 1
       RETURN
    ENDIF
+   IF (NC.EQ.-1) THEN
+   ENDIF
    CALL SELF%WRITE_START_TAG(NAME='Points')
    ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
    CALL SELF%WRITE_END_TAG(NAME='Points')
@@ -9984,6 +10012,8 @@ FUNCTION WRITE_GEO_POLY_DATA3_RANK1_R4P(SELF, NP, NC, X, Y, Z) RESULT(ERROR)
       SELF%ERROR = 1
       RETURN
    ENDIF
+   IF (NC.EQ.-1) THEN
+   ENDIF
    CALL SELF%WRITE_START_TAG(NAME='Points')
    ERROR = SELF%W_DATA(DATA_NAME='Points', X=X, Y=Y, Z=Z)
    CALL SELF%WRITE_END_TAG(NAME='Points')
@@ -10057,7 +10087,9 @@ FUNCTION WRITE_CONNECTIVITY(SELF, NC, CONNECTIVITY, OFFSET, VTKC_TYPE, FACE, FAC
    ERROR = SELF%W_DATA(DATA_NAME='offsets', X=OFFSET)
    ERROR = SELF%W_DATA(DATA_NAME='types', X=VTKC_TYPE)
    CALL SELF%WRITE_END_TAG(NAME='Cells')
-
+   
+   IF (NC.EQ.-1) THEN
+   ENDIF
    !< ADD FACES AND FACEOFFSETS TO THE CELL BLOCK FOR POLYHEDRA. IF THE CELL IS NOT A POLYHEDRON, ITS OFFSET MUST BE SET TO -1.
    IF(PRESENT(FACE).AND. PRESENT(FACEOFFSET)) THEN
         ERROR = SELF%W_DATA(DATA_NAME='Faces', X=FACE)
@@ -10787,7 +10819,8 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, N
   CHARACTER(*),                  INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
   LOGICAL,                       INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
   INTEGER(I4P)                                        :: ERROR         !< ERROR STATUS.
-
+  IF (IS_VOLATILE) THEN
+  ENDIF
   SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
   SELF%FORMAT_CH = FORMAT
   SELF%FORMAT_CH = SELF%FORMAT_CH%LOWER()
@@ -11052,6 +11085,8 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
   SUBROUTINE W_DATA_APPENDED(SELF)
   !< DO NOTHING, ASCII DATA CANNOT BE APPENDED.
   CLASS(XML_WRITER_ASCII_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
+  INTEGER(I4P)                                        :: ERROR        !< ERROR STATUS.
+  ERROR = SELF%ERROR
   ENDSUBROUTINE W_DATA_APPENDED
 ENDMODULE VTKF_FILE_XML_WRITER_ASCII_LOCAL
 
@@ -11131,7 +11166,8 @@ FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, NX1, NX2, NY1, NY2, N
   CHARACTER(*),               INTENT(IN), OPTIONAL :: MESH_KIND     !< KIND OF MESH DATA: FLOAT64, FLOAT32, ECC.
   LOGICAL,                    INTENT(IN), OPTIONAL :: IS_VOLATILE   !< FLAG TO CHECK VOLATILE WRITER.
   INTEGER(I4P)                                     :: ERROR         !< ERROR STATUS.
-
+  IF (IS_VOLATILE) THEN
+  ENDIF
   SELF%TOPOLOGY = TRIM(ADJUSTL(MESH_TOPOLOGY))
   SELF%FORMAT_CH = 'appended'
   SELF%ENCODING = FORMAT
@@ -11436,7 +11472,8 @@ SUBROUTINE W_DATA_APPENDED(SELF)
   INTEGER(I4P), ALLOCATABLE                 :: DATAARRAY_I4P(:)  !< DATAARRAY BUFFER OF I4P.
   INTEGER(I2P), ALLOCATABLE                 :: DATAARRAY_I2P(:)  !< DATAARRAY BUFFER OF I2P.
   INTEGER(I1P), ALLOCATABLE                 :: DATAARRAY_I1P(:)  !< DATAARRAY BUFFER OF I1P.
-
+  IF(TAG_ATTRIBUTES=="") THEN
+  ENDIF
   CALL SELF%WRITE_START_TAG(NAME='AppendedData', ATTRIBUTES='encoding="'//SELF%ENCODING%CHARS()//'"')
   WRITE(UNIT=SELF%XML, IOSTAT=SELF%ERROR)'_'
   ENDFILE(UNIT=SELF%SCRATCH, IOSTAT=SELF%ERROR)
@@ -11967,6 +12004,8 @@ FUNCTION W_DATA3_RANK1_I1P(SELF, DATA_NAME, X, Y, Z, IS_TUPLES) RESULT(ERROR)
    SUBROUTINE W_DATA_APPENDED(SELF)
    !< DO NOTHING, BINARY LOCAL IS NOT APPENDED.
    CLASS(XML_WRITER_BINARY_LOCAL), INTENT(INOUT) :: SELF !< WRITER.
+   INTEGER(I4P)                                         :: ERROR        !< ERROR STATUS.
+   ERROR = SELF%ERROR
    ENDSUBROUTINE W_DATA_APPENDED
 ENDMODULE VTKF_FILE_XML_WRITER_BINARY_LOCAL
 
@@ -12196,8 +12235,9 @@ PURE SUBROUTINE GET_XML_VOLATILE(SELF, XML_VOLATILE, ERROR)
    CLASS(VTK_FILE),  INTENT(IN)               :: SELF         !< VTK FILE.
    CHARACTER(LEN=:), INTENT(OUT), ALLOCATABLE :: XML_VOLATILE !< XML VOLATILE FILE.
    INTEGER(I4P),     INTENT(OUT), OPTIONAL    :: ERROR !< ERROR STATUS.
-
-   CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE, ERROR=ERROR)
+   IF (ERROR.EQ.-1) THEN
+   ENDIF
+   CALL SELF%XML_WRITER%GET_XML_VOLATILE(XML_VOLATILE=XML_VOLATILE) !, ERROR=ERROR)
    ENDSUBROUTINE GET_XML_VOLATILE
 
    FUNCTION INITIALIZE(SELF, FORMAT, FILENAME, MESH_TOPOLOGY, IS_VOLATILE, NX1, NX2, NY1, NY2, NZ1, NZ2) RESULT(ERROR)
@@ -12272,14 +12312,17 @@ FUNCTION FINALIZE(SELF) RESULT(ERROR)
 
    ERROR = 1
    IF (ALLOCATED(SELF%XML_WRITER)) ERROR = SELF%XML_WRITER%FINALIZE()
+   IF (XML_VOLATILE=="") THEN
+   ENDIF
    ENDFUNCTION FINALIZE
 
    ELEMENTAL SUBROUTINE FREE(SELF, ERROR)
    !< FREE ALLOCATED MEMORY.
    CLASS(VTK_FILE), INTENT(INOUT)         :: SELF  !< VTK FILE.
    INTEGER(I4P),    INTENT(OUT), OPTIONAL :: ERROR !< ERROR STATUS.
-
-   IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE(ERROR=ERROR)
+   IF (ERROR.EQ.-1) THEN
+   ENDIF
+   IF (ALLOCATED(SELF%XML_WRITER)) CALL SELF%XML_WRITER%FREE() !ERROR=ERROR)
    ENDSUBROUTINE FREE
 ENDMODULE VTK_FORTRAN_VTK_FILE
 
@@ -12426,9 +12469,8 @@ MODULE VTK_FDS_INTERFACE
 CONTAINS
 
 
-SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+SUBROUTINE WRITE_VTK_SL3D_WRAPPER(T,NMESHES)
 INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 REAL(EB), INTENT(IN) :: T
 TYPE (SLICE_TYPE), POINTER :: SL
 INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
@@ -12487,9 +12529,8 @@ END SUBROUTINE WRITE_VTK_SL3D_WRAPPER
 
 
 
-SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+SUBROUTINE WRITE_VTK_SM3D_WRAPPER(T,NMESHES)
 INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 REAL(EB), INTENT(IN) :: T
 INTEGER :: I,ITM,ITM1,N
 REAL(FB) :: STIME
@@ -12530,12 +12571,11 @@ END SUBROUTINE WRITE_VTK_SM3D_WRAPPER
 
 
 
-SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES,MESH_TOPOLOGY)
+SUBROUTINE WRITE_VTK_BNDF_WRAPPER(T,NMESHES)
 INTEGER, INTENT(IN) :: NMESHES
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 REAL(EB), INTENT(IN) :: T
 TYPE(BOUNDARY_FILE_TYPE), POINTER :: BF
-INTEGER :: I,NQT,I1,I2,J1,J2,K1,K2,IQ,ITM,ITM1
+INTEGER :: I,IQ,ITM,ITM1
 REAL(FB) :: STIME
 REAL(EB) :: TT
 TYPE(PVTK_FILE)          :: A_PVTK_FILE       !< A parallel (partioned) VTK file.
@@ -12575,14 +12615,13 @@ END SUBROUTINE WRITE_VTK_BNDF_WRAPPER
 
 
 
-SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, &
+SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, &
                                         NC, NP, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
 
 INTEGER :: NX, NY, NZ, NC, NP, I, J, K, IFACT, JFACT, KFACT
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 INTEGER, INTENT(IN) :: NM
 
 NX = SIZE(MESHES(NM)%X)
@@ -12639,14 +12678,13 @@ SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, MESH_TOPOLOGY, &
 ENDSUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY
          
 
-SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, MESH_TOPOLOGY, &
+SUBROUTINE BUILD_VTK_SOLID_PHASE_GEOMETRY(NM, PA, &
                                           NCELLS, NPOINTS, X_PTS, Y_PTS, Z_PTS, CONNECT, OFFSETS, VTKC_TYPE)
 
-INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,JFACT,KFACT,L,L1,L2,N,N1,N2
+INTEGER :: NX,NY,NZ,NCELLS,NPOINTS,I,J,K,IFACT,L1,L2,N1,N2
 REAL(FB), ALLOCATABLE, DIMENSION(:) :: X_PTS, Y_PTS, Z_PTS
 INTEGER(IB32), ALLOCATABLE, DIMENSION(:) :: CONNECT, OFFSETS
 INTEGER(IB8), ALLOCATABLE, DIMENSION(:) :: VTKC_TYPE
-CHARACTER(LEN=*), INTENT(IN) :: MESH_TOPOLOGY
 INTEGER, INTENT(IN) :: NM
 TYPE(PATCH_TYPE), POINTER, INTENT(IN) :: PA
 

From 7e36630fe512687b5d4b46b4226525bdbe13fe3e Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Mon, 8 Jan 2024 14:14:38 -0500
Subject: [PATCH 30/31] add vtk output for particles

---
 Source/cons.f90 |   3 +-
 Source/dump.f90 | 113 ++++++++++++++++++++++++++++++------------------
 Source/vtkf.f90 |  46 ++++++++++++++++++++
 3 files changed, 120 insertions(+), 42 deletions(-)

diff --git a/Source/cons.f90 b/Source/cons.f90
index 76b5c4dc9d6..bd07a746041 100644
--- a/Source/cons.f90
+++ b/Source/cons.f90
@@ -553,7 +553,8 @@ MODULE GLOBAL_CONSTANTS
 CHARACTER(80), ALLOCATABLE, DIMENSION(:)   :: FN_VEG_OUT,FN_GEOM, FN_CFACE_GEOM
 CHARACTER(80), ALLOCATABLE, DIMENSION(:,:) :: FN_SLCF,FN_SLCF_GEOM,FN_BNDF,FN_BNDG, &
                                               FN_ISOF,FN_ISOF2,FN_SMOKE3D,FN_RADF
-CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK,FN_PART_VTK
+CHARACTER(200), ALLOCATABLE, DIMENSION(:)  :: FN_SL3D_VTK,FN_SMOKE3D_VTK,FN_BNDF_VTK
+CHARACTER(200), ALLOCATABLE, DIMENSION(:,:):: FN_PART_VTK
 
 CHARACTER(9) :: FMT_R
 LOGICAL :: OUT_FILE_OPENED=.FALSE.
diff --git a/Source/dump.f90 b/Source/dump.f90
index 79173bab976..e5e32979916 100644
--- a/Source/dump.f90
+++ b/Source/dump.f90
@@ -21,6 +21,7 @@ MODULE DUMP
 USE CC_SCALARS, ONLY : ADD_Q_DOT_CUTCELLS,GET_PRES_CFACE,GET_PRES_CFACE_TEST,GET_UVWGAS_CFACE,GET_MUDNS_CFACE
 USE VTK_FDS_INTERFACE, ONLY : BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
                 WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
+                WRITE_VTK_PART_WRAPPER,&
                 DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 USE VTK_FORTRAN, ONLY : VTK_FILE, PVTK_FILE
 
@@ -95,7 +96,7 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 TNOW = CURRENT_TIME()
 
 IF (T>=PART_CLOCK(PART_COUNTER(NM)) .AND. PARTICLE_FILE) THEN
-   CALL DUMP_PART(T,NM)
+   CALL DUMP_PART(T,NM,0)
    DO WHILE(PART_COUNTER(NM)<SIZE(PART_CLOCK)-1)
       PART_COUNTER(NM) = PART_COUNTER(NM) + 1
       IF (PART_CLOCK(PART_COUNTER(NM))>=T) EXIT
@@ -174,9 +175,9 @@ SUBROUTINE DUMP_MESH_OUTPUTS(T,DT,NM)
 ! VTK Particle data
 IF (T>=PART_VTK_CLOCK(PART_VTK_COUNTER(NM)) .AND. PARTICLE_FILE) THEN
    IF (NM .EQ. 1) THEN
-      !CALL WRITE_VTK_PART_WRAPPER(T,NMESHES,'PPolyData')
+      CALL WRITE_VTK_PART_WRAPPER(T,NMESHES)
    ENDIF
-   !CALL DUMP_PART(T,NM)
+   CALL DUMP_PART(T,NM,1)
    DO WHILE(PART_VTK_COUNTER(NM)<SIZE(PART_VTK_CLOCK)-1)
       PART_VTK_COUNTER(NM) = PART_VTK_COUNTER(NM) + 1
       IF (PART_VTK_CLOCK(PART_VTK_COUNTER(NM))>=T) EXIT
@@ -422,7 +423,7 @@ SUBROUTINE ASSIGN_FILE_NAMES
 ALLOCATE(FN_SMOKE3D_VTK(NMESHES+1))
 ALLOCATE(LU_SMOKE3D_VTK(NMESHES+1))
 ALLOCATE(FN_BNDF_VTK(NMESHES+1))
-ALLOCATE(FN_PART_VTK(NMESHES+1))
+ALLOCATE(FN_PART_VTK(N_LAGRANGIAN_CLASSES,NMESHES+1))
 
 MESH_LOOP: DO NM=1,NMESHES
 
@@ -4037,15 +4038,16 @@ END SUBROUTINE WRITE_DIAGNOSTICS
 !>
 !> \param T Current simulation time (s)
 !> \param NM Mesh number
+!> \param IFRMT PRT5 (IFRMT=0) or VTK (IFRMT=1)
 
-SUBROUTINE DUMP_PART(T,NM)
+SUBROUTINE DUMP_PART(T,NM,IFRMT)
 
 USE MEMORY_FUNCTIONS, ONLY: CHKMEMERR
 
-INTEGER, INTENT(IN)  :: NM
+INTEGER, INTENT(IN)  :: NM,IFRMT
 REAL(EB), INTENT(IN) :: T
 REAL(EB) :: STIME
-INTEGER  :: NPP,NPLIM,IP,N,NN,IZERO
+INTEGER  :: NPP,NPLIM,IP,N,NN,IZERO,ITM,ITM1
 REAL(EB), ALLOCATABLE, DIMENSION(:) :: XP,YP,ZP
 REAL(EB), ALLOCATABLE, DIMENSION(:,:) :: QP
 INTEGER, ALLOCATABLE, DIMENSION(:) :: TA
@@ -4053,15 +4055,25 @@ SUBROUTINE DUMP_PART(T,NM)
 REAL(FB) :: PFACTOR_FB
 INTEGER, PARAMETER :: PART_BOUNDFILE_VERSION=1
 TYPE (BOUNDARY_COORD_TYPE), POINTER :: BC
+TYPE(VTK_FILE)     :: A_VTK_FILE                    ! A VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
 
 CALL POINT_TO_MESH(NM)
 
 ! Write the current time to the prt5 file, then start looping through the particle classes
 
 STIME = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(STIME)
+ITM1 = NINT(ABS(STIME-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
 
-WRITE(LU_PART(NM)) REAL(STIME,FB)
-WRITE(LU_PART(NM+NMESHES),'(ES13.6,1X,I4,1X,I4)')STIME, N_LAGRANGIAN_CLASSES, PART_BOUNDFILE_VERSION
+IF (IFRMT.EQ.0) THEN
+   WRITE(LU_PART(NM)) REAL(STIME,FB)
+   WRITE(LU_PART(NM+NMESHES),'(ES13.6,1X,I4,1X,I4)')STIME, N_LAGRANGIAN_CLASSES, PART_BOUNDFILE_VERSION
+ENDIF
 
 LAGRANGIAN_PARTICLE_CLASS_LOOP: DO N=1,N_LAGRANGIAN_CLASSES
 
@@ -4101,43 +4113,62 @@ SUBROUTINE DUMP_PART(T,NM)
             Y_INDEX=LPC%QUANTITIES_Y_INDEX(NN),Z_INDEX=LPC%QUANTITIES_Z_INDEX(NN),MESH_NUMBER=NM)
       ENDDO
    ENDDO LOAD_LOOP
+   
+   IF (IFRMT.EQ.0) THEN
+      ! Dump particle data into the .prt5 file
 
-   ! Dump particle data into the .prt5 file
-
-   WRITE(LU_PART(NM)) NPLIM
-   WRITE(LU_PART(NM)) (REAL(XP(IP),FB),IP=1,NPLIM),(REAL(YP(IP),FB),IP=1,NPLIM),(REAL(ZP(IP),FB),IP=1,NPLIM)
-   WRITE(LU_PART(NM)) (TA(IP),IP=1,NPLIM)
-   IF (LPC%DEBUG) THEN
-      PFACTOR = 0.0_EB
-      IF(NPLIM > 1) PFACTOR = 2.0_EB*STIME/REAL(NPLIM-1,FB)
-      IF (LPC%N_QUANTITIES > 0) THEN
-         PFACTOR_FB = REAL(PFACTOR,FB)
-         WRITE(LU_PART(NM)) ((REAL(-STIME,FB)+REAL(IP-1,FB)*PFACTOR_FB,IP=1,NPLIM),NN=1,LPC%N_QUANTITIES)
-      ENDIF
-   ELSE
-      IF (LPC%N_QUANTITIES > 0) WRITE(LU_PART(NM)) ((REAL(QP(IP,NN),FB),IP=1,NPLIM),NN=1,LPC%N_QUANTITIES)
-   ENDIF
-
-   WRITE(LU_PART(NM+NMESHES),'(I4,1X,I7)')LPC%N_QUANTITIES, NPLIM
-   DO NN = 1, LPC%N_QUANTITIES
+      WRITE(LU_PART(NM)) NPLIM
+      WRITE(LU_PART(NM)) (REAL(XP(IP),FB),IP=1,NPLIM),(REAL(YP(IP),FB),IP=1,NPLIM),(REAL(ZP(IP),FB),IP=1,NPLIM)
+      WRITE(LU_PART(NM)) (TA(IP),IP=1,NPLIM)
       IF (LPC%DEBUG) THEN
-         PART_MIN = -STIME
-         PART_MAX =  STIME
+         PFACTOR = 0.0_EB
+         IF(NPLIM > 1) PFACTOR = 2.0_EB*STIME/REAL(NPLIM-1,FB)
+         IF (LPC%N_QUANTITIES > 0) THEN
+            PFACTOR_FB = REAL(PFACTOR,FB)
+            WRITE(LU_PART(NM)) ((REAL(-STIME,FB)+REAL(IP-1,FB)*PFACTOR_FB,IP=1,NPLIM),NN=1,LPC%N_QUANTITIES)
+         ENDIF
       ELSE
-         IF (NPLIM > 0) THEN
-            PART_MAX = QP(1,NN)
-            PART_MIN = PART_MAX
-            DO IP = 2, NPLIM
-               PART_MIN = MIN(QP(IP,NN),PART_MIN)
-               PART_MAX = MAX(QP(IP,NN),PART_MAX)
-            ENDDO
+         IF (LPC%N_QUANTITIES > 0) WRITE(LU_PART(NM)) ((REAL(QP(IP,NN),FB),IP=1,NPLIM),NN=1,LPC%N_QUANTITIES)
+      ENDIF
+
+      WRITE(LU_PART(NM+NMESHES),'(I4,1X,I7)')LPC%N_QUANTITIES, NPLIM
+      DO NN = 1, LPC%N_QUANTITIES
+         IF (LPC%DEBUG) THEN
+            PART_MIN = -STIME
+            PART_MAX =  STIME
          ELSE
-            PART_MIN = 1.0_EB
-            PART_MAX = 0.0_EB
+            IF (NPLIM > 0) THEN
+               PART_MAX = QP(1,NN)
+               PART_MIN = PART_MAX
+               DO IP = 2, NPLIM
+                  PART_MIN = MIN(QP(IP,NN),PART_MIN)
+                  PART_MAX = MAX(QP(IP,NN),PART_MAX)
+               ENDDO
+            ELSE
+               PART_MIN = 1.0_EB
+               PART_MAX = 0.0_EB
+            ENDIF
          ENDIF
-      ENDIF
-      WRITE(LU_PART(NM+NMESHES),'(5X,ES13.6,1X,ES13.6)')PART_MIN, PART_MAX
-   ENDDO
+         WRITE(LU_PART(NM+NMESHES),'(5X,ES13.6,1X,ES13.6)')PART_MIN, PART_MAX
+      ENDDO
+   ELSEIF (IFRMT.EQ.1) THEN
+      WRITE(FN_PART_VTK(N,NM),'(A,A,A,A,A,I0,A,I8.8,I2.2,A)') "",TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',NM,'_',ITM,ITM1,'.vtp'
+      IF (VTK_BINARY) THEN
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='raw', FILENAME=FN_PART_VTK(N,NM), MESH_TOPOLOGY='PolyData')
+      ELSE
+         VTK_ERROR = A_VTK_FILE%INITIALIZE(FORMAT='ascii', FILENAME=FN_PART_VTK(N,NM), MESH_TOPOLOGY='PolyData')
+      ENDIF ! do not change capitalization on mesh topology
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE(NP=NPP, NC=0)
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_GEO(NP=NPP, NC=0, X=XP(1:NPP), Y=YP(1:NPP), Z=ZP(1:NPP))
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='OPEN')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME='TAG', X=TA)
+      DO NN=1,LPC%N_QUANTITIES
+         VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(DATA_NAME=LPC%SMOKEVIEW_LABEL(NN), X=QP(1:NPP,N))
+      ENDDO
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE', ACTION='CLOSE')
+      VTK_ERROR = A_VTK_FILE%XML_WRITER%WRITE_PIECE()
+      VTK_ERROR = A_VTK_FILE%FINALIZE()
+   ENDIF
 
    DEALLOCATE(XP)
    DEALLOCATE(YP)
diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index a8bb8d9a407..2b29962991e 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -12464,6 +12464,7 @@ MODULE VTK_FDS_INTERFACE
 
 PUBLIC BUILD_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_SOLID_PHASE_GEOMETRY,&
        WRITE_VTK_SL3D_WRAPPER,WRITE_VTK_SM3D_WRAPPER,WRITE_VTK_BNDF_WRAPPER,&
+       WRITE_VTK_PART_WRAPPER,&
        DEALLOCATE_VTK_GAS_PHASE_GEOMETRY,BUILD_VTK_GEOM_GEOMETRY
 
 CONTAINS
@@ -12613,6 +12614,51 @@ END SUBROUTINE WRITE_VTK_BNDF_WRAPPER
 
 
 
+SUBROUTINE WRITE_VTK_PART_WRAPPER(T,NMESHES)
+INTEGER, INTENT(IN) :: NMESHES
+REAL(EB), INTENT(IN) :: T
+TYPE (LAGRANGIAN_PARTICLE_CLASS_TYPE), POINTER :: LPC
+INTEGER :: I,IQ,ITM,ITM1,N,NN
+REAL(FB) :: STIME
+REAL(EB) :: TT
+TYPE(PVTK_FILE)          :: A_PVTK_FILE       !< A parallel (partioned) VTK file.
+INTEGER(IB8)  :: VTK_ERROR=0_IB8                    !< IO Error status.
+CHARACTER(200) :: TMP_FILE
+
+! Generate filename
+STIME = REAL(T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR,FB)
+TT   = T_BEGIN + (T-T_BEGIN)*TIME_SHRINK_FACTOR
+ITM  = INT(TT)
+ITM1 = NINT(ABS(TT-ITM)*100)
+IF (ITM1==100) THEN
+   ITM = ITM+1
+   ITM1 = 0
+ENDIF
+
+DO N=1,N_LAGRANGIAN_CLASSES
+   LPC => LAGRANGIAN_PARTICLE_CLASS(N)
+   WRITE(FN_PART_VTK(N,NMESHES+1),'(A,A,A,A,A,I8.8,I2.2,A)') "",TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',ITM,ITM1,'.pvtp'
+   VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_PART_VTK(N,NMESHES+1), MESH_TOPOLOGY='PPolyData',&
+                                      MESH_KIND='Float64')
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN')
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="Tag", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1)
+   ! Add PointData arrays
+   DO NN=1,LPC%N_QUANTITIES
+      VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(LPC%SMOKEVIEW_LABEL(NN)), &
+                                                              DATA_TYPE='Float64', NUMBER_OF_COMPONENTS=1)
+   ENDDO
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='CLOSE')
+   
+   DO I=1,NMESHES
+      WRITE(TMP_FILE,'(A,A,A,A,I0,A,I8.8,I2.2,A)') TRIM(CHID),'_PART_',TRIM(LPC%ID),'_',I,'_',ITM,ITM1,'.vtp'
+      VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_GEO(SOURCE=TMP_FILE)
+   ENDDO
+   VTK_ERROR = A_PVTK_FILE%FINALIZE()
+ENDDO
+
+END SUBROUTINE WRITE_VTK_PART_WRAPPER
+
+
 
 
 SUBROUTINE BUILD_VTK_GAS_PHASE_GEOMETRY(NM, &

From 3c702f26d64243b2056030e71dd36fdf5be4d922 Mon Sep 17 00:00:00 2001
From: Jonathan Hodges <johodges@vt.edu>
Date: Mon, 8 Jan 2024 14:20:23 -0500
Subject: [PATCH 31/31] Fix capitalization in vtk part TAG

---
 Source/vtkf.f90 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/vtkf.f90 b/Source/vtkf.f90
index 2b29962991e..d9b56f897ad 100644
--- a/Source/vtkf.f90
+++ b/Source/vtkf.f90
@@ -12641,7 +12641,7 @@ SUBROUTINE WRITE_VTK_PART_WRAPPER(T,NMESHES)
    VTK_ERROR = A_PVTK_FILE%INITIALIZE(FILENAME=FN_PART_VTK(N,NMESHES+1), MESH_TOPOLOGY='PPolyData',&
                                       MESH_KIND='Float64')
    VTK_ERROR = A_PVTK_FILE%XML_WRITER%W_DATA(LOCATION='NODE',ACTION='OPEN')
-   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="Tag", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1)
+   VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME="TAG", DATA_TYPE='Int32', NUMBER_OF_COMPONENTS=1)
    ! Add PointData arrays
    DO NN=1,LPC%N_QUANTITIES
       VTK_ERROR = A_PVTK_FILE%XML_WRITER%WRITE_PARALLEL_DATAARRAY(DATA_NAME=TRIM(LPC%SMOKEVIEW_LABEL(NN)), &