input_output.f90

Go to the documentation of this file.

MODULE input_output

  USE base_routines
  USE constants
  USE kinds
  USE iso_varying_string
  USE strings

#include "macros.h"  

  IMPLICIT NONE

  PRIVATE
  
  !Module parameters

  INTEGER(INTG), PARAMETER :: write_string_matrix_name_only=1
  INTEGER(INTG), PARAMETER :: write_string_matrix_name_and_indices=2

  !Module types

  !Interfaces

  INTERFACE write_string
    MODULE PROCEDURE write_string_c
    MODULE PROCEDURE write_string_vs
  END INTERFACE write_string

  INTERFACE writestring
    MODULE PROCEDURE write_string_c
    MODULE PROCEDURE write_string_vs
  END INTERFACE writestring

  INTERFACE write_string_value
    MODULE PROCEDURE write_string_value_c
    MODULE PROCEDURE write_string_value_dp
    MODULE PROCEDURE write_string_value_intg
    MODULE PROCEDURE write_string_value_lintg
    MODULE PROCEDURE write_string_value_l
    MODULE PROCEDURE write_string_value_sp
    MODULE PROCEDURE write_string_value_vs
  END INTERFACE write_string_value

  INTERFACE writestringvalue
    MODULE PROCEDURE write_string_value_c
    MODULE PROCEDURE write_string_value_dp
    MODULE PROCEDURE write_string_value_intg
    MODULE PROCEDURE write_string_value_lintg
    MODULE PROCEDURE write_string_value_l
    MODULE PROCEDURE write_string_value_sp
    MODULE PROCEDURE write_string_value_vs
  END INTERFACE writestringvalue

  INTERFACE write_string_two_value
    MODULE PROCEDURE write_string_two_value_c_c
    MODULE PROCEDURE write_string_two_value_c_dp
    MODULE PROCEDURE write_string_two_value_c_intg
    MODULE PROCEDURE write_string_two_value_c_l
    MODULE PROCEDURE write_string_two_value_c_sp
    MODULE PROCEDURE write_string_two_value_c_vs
    MODULE PROCEDURE write_string_two_value_dp_c
    MODULE PROCEDURE write_string_two_value_dp_dp
    MODULE PROCEDURE write_string_two_value_dp_intg
    MODULE PROCEDURE write_string_two_value_dp_l
    MODULE PROCEDURE write_string_two_value_dp_sp
    MODULE PROCEDURE write_string_two_value_dp_vs
    MODULE PROCEDURE write_string_two_value_intg_c
    MODULE PROCEDURE write_string_two_value_intg_dp
    MODULE PROCEDURE write_string_two_value_intg_intg
    MODULE PROCEDURE write_string_two_value_intg_l
    MODULE PROCEDURE write_string_two_value_intg_sp
    MODULE PROCEDURE write_string_two_value_intg_vs
    MODULE PROCEDURE write_string_two_value_l_c
    MODULE PROCEDURE write_string_two_value_l_dp
    MODULE PROCEDURE write_string_two_value_l_intg
    MODULE PROCEDURE write_string_two_value_l_l
    MODULE PROCEDURE write_string_two_value_l_sp
    MODULE PROCEDURE write_string_two_value_l_vs
    MODULE PROCEDURE write_string_two_value_sp_c
    MODULE PROCEDURE write_string_two_value_sp_dp
    MODULE PROCEDURE write_string_two_value_sp_intg
    MODULE PROCEDURE write_string_two_value_sp_l
    MODULE PROCEDURE write_string_two_value_sp_sp
    MODULE PROCEDURE write_string_two_value_sp_vs
    MODULE PROCEDURE write_string_two_value_vs_c
    MODULE PROCEDURE write_string_two_value_vs_dp
    MODULE PROCEDURE write_string_two_value_vs_intg
    MODULE PROCEDURE write_string_two_value_vs_l
    MODULE PROCEDURE write_string_two_value_vs_sp
    MODULE PROCEDURE write_string_two_value_vs_vs
  END INTERFACE write_string_two_value

  INTERFACE writestringtwovalue
    MODULE PROCEDURE write_string_two_value_c_c
    MODULE PROCEDURE write_string_two_value_c_dp
    MODULE PROCEDURE write_string_two_value_c_intg
    MODULE PROCEDURE write_string_two_value_c_l
    MODULE PROCEDURE write_string_two_value_c_sp
    MODULE PROCEDURE write_string_two_value_c_vs
    MODULE PROCEDURE write_string_two_value_dp_c
    MODULE PROCEDURE write_string_two_value_dp_dp
    MODULE PROCEDURE write_string_two_value_dp_intg
    MODULE PROCEDURE write_string_two_value_dp_l
    MODULE PROCEDURE write_string_two_value_dp_sp
    MODULE PROCEDURE write_string_two_value_dp_vs
    MODULE PROCEDURE write_string_two_value_intg_c
    MODULE PROCEDURE write_string_two_value_intg_dp
    MODULE PROCEDURE write_string_two_value_intg_intg
    MODULE PROCEDURE write_string_two_value_intg_l
    MODULE PROCEDURE write_string_two_value_intg_sp
    MODULE PROCEDURE write_string_two_value_intg_vs
    MODULE PROCEDURE write_string_two_value_l_c
    MODULE PROCEDURE write_string_two_value_l_dp
    MODULE PROCEDURE write_string_two_value_l_intg
    MODULE PROCEDURE write_string_two_value_l_l
    MODULE PROCEDURE write_string_two_value_l_sp
    MODULE PROCEDURE write_string_two_value_l_vs
    MODULE PROCEDURE write_string_two_value_sp_c
    MODULE PROCEDURE write_string_two_value_sp_dp
    MODULE PROCEDURE write_string_two_value_sp_intg
    MODULE PROCEDURE write_string_two_value_sp_l
    MODULE PROCEDURE write_string_two_value_sp_sp
    MODULE PROCEDURE write_string_two_value_sp_vs
    MODULE PROCEDURE write_string_two_value_vs_c
    MODULE PROCEDURE write_string_two_value_vs_dp
    MODULE PROCEDURE write_string_two_value_vs_intg
    MODULE PROCEDURE write_string_two_value_vs_l
    MODULE PROCEDURE write_string_two_value_vs_sp
    MODULE PROCEDURE write_string_two_value_vs_vs
  END INTERFACE writestringtwovalue

  INTERFACE write_string_fmt_value
    MODULE PROCEDURE write_string_fmt_value_c
    MODULE PROCEDURE write_string_fmt_value_dp
    MODULE PROCEDURE write_string_fmt_value_intg
    MODULE PROCEDURE write_string_fmt_value_lintg
    MODULE PROCEDURE write_string_fmt_value_l
    MODULE PROCEDURE write_string_fmt_value_sp
    MODULE PROCEDURE write_string_fmt_value_vs
  END INTERFACE write_string_fmt_value
  
  INTERFACE writestringfmtvalue
    MODULE PROCEDURE write_string_fmt_value_c
    MODULE PROCEDURE write_string_fmt_value_dp
    MODULE PROCEDURE write_string_fmt_value_intg
    MODULE PROCEDURE write_string_fmt_value_lintg
    MODULE PROCEDURE write_string_fmt_value_l
    MODULE PROCEDURE write_string_fmt_value_sp
    MODULE PROCEDURE write_string_fmt_value_vs
  END INTERFACE writestringfmtvalue
  
  INTERFACE write_string_fmt_two_value
    MODULE PROCEDURE write_string_fmt_two_value_c_c
    MODULE PROCEDURE write_string_fmt_two_value_c_dp
    MODULE PROCEDURE write_string_fmt_two_value_c_intg
    MODULE PROCEDURE write_string_fmt_two_value_c_l
    MODULE PROCEDURE write_string_fmt_two_value_c_sp
    MODULE PROCEDURE write_string_fmt_two_value_c_vs
    MODULE PROCEDURE write_string_fmt_two_value_dp_c
    MODULE PROCEDURE write_string_fmt_two_value_dp_dp
    MODULE PROCEDURE write_string_fmt_two_value_dp_intg
    MODULE PROCEDURE write_string_fmt_two_value_dp_l
    MODULE PROCEDURE write_string_fmt_two_value_dp_sp
    MODULE PROCEDURE write_string_fmt_two_value_dp_vs
    MODULE PROCEDURE write_string_fmt_two_value_intg_c
    MODULE PROCEDURE write_string_fmt_two_value_intg_dp
    MODULE PROCEDURE write_string_fmt_two_value_intg_intg
    MODULE PROCEDURE write_string_fmt_two_value_intg_l
    MODULE PROCEDURE write_string_fmt_two_value_intg_sp
    MODULE PROCEDURE write_string_fmt_two_value_intg_vs
    MODULE PROCEDURE write_string_fmt_two_value_l_c
    MODULE PROCEDURE write_string_fmt_two_value_l_dp
    MODULE PROCEDURE write_string_fmt_two_value_l_intg
    MODULE PROCEDURE write_string_fmt_two_value_l_l
    MODULE PROCEDURE write_string_fmt_two_value_l_sp
    MODULE PROCEDURE write_string_fmt_two_value_l_vs
    MODULE PROCEDURE write_string_fmt_two_value_sp_c
    MODULE PROCEDURE write_string_fmt_two_value_sp_dp
    MODULE PROCEDURE write_string_fmt_two_value_sp_intg
    MODULE PROCEDURE write_string_fmt_two_value_sp_l
    MODULE PROCEDURE write_string_fmt_two_value_sp_sp
    MODULE PROCEDURE write_string_fmt_two_value_sp_vs
    MODULE PROCEDURE write_string_fmt_two_value_vs_c
    MODULE PROCEDURE write_string_fmt_two_value_vs_dp
    MODULE PROCEDURE write_string_fmt_two_value_vs_intg
    MODULE PROCEDURE write_string_fmt_two_value_vs_l
    MODULE PROCEDURE write_string_fmt_two_value_vs_sp
    MODULE PROCEDURE write_string_fmt_two_value_vs_vs
  END INTERFACE write_string_fmt_two_value

  INTERFACE writestringfmttwovalue
    MODULE PROCEDURE write_string_fmt_two_value_c_c
    MODULE PROCEDURE write_string_fmt_two_value_c_dp
    MODULE PROCEDURE write_string_fmt_two_value_c_intg
    MODULE PROCEDURE write_string_fmt_two_value_c_l
    MODULE PROCEDURE write_string_fmt_two_value_c_sp
    MODULE PROCEDURE write_string_fmt_two_value_c_vs
    MODULE PROCEDURE write_string_fmt_two_value_dp_c
    MODULE PROCEDURE write_string_fmt_two_value_dp_dp
    MODULE PROCEDURE write_string_fmt_two_value_dp_intg
    MODULE PROCEDURE write_string_fmt_two_value_dp_l
    MODULE PROCEDURE write_string_fmt_two_value_dp_sp
    MODULE PROCEDURE write_string_fmt_two_value_dp_vs
    MODULE PROCEDURE write_string_fmt_two_value_intg_c
    MODULE PROCEDURE write_string_fmt_two_value_intg_dp
    MODULE PROCEDURE write_string_fmt_two_value_intg_intg
    MODULE PROCEDURE write_string_fmt_two_value_intg_l
    MODULE PROCEDURE write_string_fmt_two_value_intg_sp
    MODULE PROCEDURE write_string_fmt_two_value_intg_vs
    MODULE PROCEDURE write_string_fmt_two_value_l_c
    MODULE PROCEDURE write_string_fmt_two_value_l_dp
    MODULE PROCEDURE write_string_fmt_two_value_l_intg
    MODULE PROCEDURE write_string_fmt_two_value_l_l
    MODULE PROCEDURE write_string_fmt_two_value_l_sp
    MODULE PROCEDURE write_string_fmt_two_value_l_vs
    MODULE PROCEDURE write_string_fmt_two_value_sp_c
    MODULE PROCEDURE write_string_fmt_two_value_sp_dp
    MODULE PROCEDURE write_string_fmt_two_value_sp_intg
    MODULE PROCEDURE write_string_fmt_two_value_sp_l
    MODULE PROCEDURE write_string_fmt_two_value_sp_sp
    MODULE PROCEDURE write_string_fmt_two_value_sp_vs
    MODULE PROCEDURE write_string_fmt_two_value_vs_c
    MODULE PROCEDURE write_string_fmt_two_value_vs_dp
    MODULE PROCEDURE write_string_fmt_two_value_vs_intg
    MODULE PROCEDURE write_string_fmt_two_value_vs_l
    MODULE PROCEDURE write_string_fmt_two_value_vs_sp
    MODULE PROCEDURE write_string_fmt_two_value_vs_vs
  END INTERFACE writestringfmttwovalue

  INTERFACE write_string_vector
    MODULE PROCEDURE write_string_vector_dp
    MODULE PROCEDURE write_string_vector_intg
    MODULE PROCEDURE write_string_vector_lintg
    MODULE PROCEDURE write_string_vector_l
    MODULE PROCEDURE write_string_vector_sp
  END INTERFACE write_string_vector
  
  INTERFACE writestringvector
    MODULE PROCEDURE write_string_vector_dp
    MODULE PROCEDURE write_string_vector_intg
    MODULE PROCEDURE write_string_vector_lintg
    MODULE PROCEDURE write_string_vector_l
    MODULE PROCEDURE write_string_vector_sp
  END INTERFACE writestringvector
  
  INTERFACE write_string_idx_vector
    MODULE PROCEDURE write_string_idx_vector_dp
    MODULE PROCEDURE write_string_idx_vector_intg
    MODULE PROCEDURE write_string_idx_vector_lintg
    MODULE PROCEDURE write_string_idx_vector_l
    MODULE PROCEDURE write_string_idx_vector_sp
  END INTERFACE write_string_idx_vector

  INTERFACE writestringidxvector
    MODULE PROCEDURE write_string_idx_vector_dp
    MODULE PROCEDURE write_string_idx_vector_intg
    MODULE PROCEDURE write_string_idx_vector_lintg
    MODULE PROCEDURE write_string_idx_vector_l
    MODULE PROCEDURE write_string_idx_vector_sp
  END INTERFACE writestringidxvector

  INTERFACE write_string_matrix
    MODULE PROCEDURE write_string_matrix_dp
    MODULE PROCEDURE write_string_matrix_intg
    MODULE PROCEDURE write_string_matrix_lintg
    MODULE PROCEDURE write_string_matrix_l
    MODULE PROCEDURE write_string_matrix_sp
  END INTERFACE write_string_matrix

  INTERFACE writestringmatrix
    MODULE PROCEDURE write_string_matrix_dp
    MODULE PROCEDURE write_string_matrix_intg
    MODULE PROCEDURE write_string_matrix_lintg
    MODULE PROCEDURE write_string_matrix_l
    MODULE PROCEDURE write_string_matrix_sp
  END INTERFACE writestringmatrix

  PUBLIC write_string_matrix_name_only,write_string_matrix_name_and_indices
  
  PUBLIC write_string,write_string_value,write_string_two_value,write_string_fmt_value,write_string_fmt_two_value, &
    & write_string_vector,write_string_idx_vector,write_string_matrix

  PUBLIC writestring,writestringvalue,writestringtwovalue,writestringfmtvalue,writestringfmttwovalue,writestringvector, &
    & writestringidxvector,writestringmatrix

  !Module variables

CONTAINS

  !!TODO: put back enters,exits etc.
 
  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_c(ID,STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables

!    ENTERS("WRITE_STRING_C",ERR,ERROR,*999)
        
    WRITE(op_string,'(A)') string
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_C")
    RETURN
999 errorsexits("WRITE_STRING_C",err,error)
    RETURN 1   
  END SUBROUTINE write_string_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vs(ID,STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    TYPE(varying_string), INTENT(IN) :: STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables

!    ENTERS("WRITE_STRING_VS",ERR,ERROR,*999)
        
    WRITE(op_string,'(A)') char(string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VS")
    RETURN
999 errorsexits("WRITE_STRING_VS",err,error)
    RETURN 1   
  END SUBROUTINE write_string_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_c(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_VALUE_C",ERR,ERROR,*999)
        
    local_string=first_string//value(1:len_trim(VALUE))
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_C")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_C",err,error)
!    EXITS("WRITE_STRING_VALUE_C")
    RETURN 1   
  END SUBROUTINE write_string_value_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_dp(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_VALUE_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_DP")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_DP",err,error)
!    EXITS("WRITE_STRING_VALUE_DP")
    RETURN 1   
  END SUBROUTINE write_string_value_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_intg(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_VALUE_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_INTG")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_INTG",err,error)
!    EXITS("WRITE_STRING_VALUE_INTG")
    RETURN 1   
  END SUBROUTINE write_string_value_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_lintg(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(LINTG), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_VALUE_LINTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_LINTG")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_LINTG",err,error)
!    EXITS("WRITE_STRING_VALUE_LINTG")
    RETURN 1   
  END SUBROUTINE write_string_value_lintg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_l(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_VALUE_L",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(VALUE,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_L")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_L",err,error)
!    EXITS("WRITE_STRING_VALUE_L")
    RETURN 1   
  END SUBROUTINE write_string_value_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_sp(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    CHARACTER(LEN=1) :: FORMAT_STRING = "*"
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_VALUE_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,format_string,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_VALUE_SP")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_SP",err,error)
!    EXITS("WRITE_STRING_VALUE_SP")
    RETURN 1   
  END SUBROUTINE write_string_value_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_value_vs(ID,FIRST_STRING,VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_VALUE_VS",ERR,ERROR,*999)

    IF(VALUE==" ") THEN
      local_string=first_string
    ELSE
      local_string=first_string//VALUE
    ENDIF
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)

!    EXITS("WRITE_STRING_VALUE_VS")
    RETURN
999 errorsexits("WRITE_STRING_VALUE_VS",err,error)
!    EXITS("WRITE_STRING_VALUE_VS")
    RETURN 1   
  END SUBROUTINE write_string_value_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_C_C",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_TWO_VALUE_C_DP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_C_INTG",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_C_L",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_TWO_VALUE_C_SP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_c_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_C_VS",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_C_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_C_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_C_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_c_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_DP_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_DP_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_DP_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_DP_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_DP_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_dp_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_DP_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_DP_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_DP_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_DP_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_dp_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_INTG_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_INTG_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_INTG_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_INTG_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_INTG_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_intg_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_INTG_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_INTG_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_INTG_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_intg_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_L_C",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_L_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_L_DP",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_L_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_L_INTG",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_L_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_L_L",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_L_INTG_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_TWO_VALUE_L_SP",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_L_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_l_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_L_VS",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_L_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_L_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_L_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_l_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_SP_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_SP_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_TWO_VALUE_SP_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_SP_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_TWO_VALUE_SP_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_sp_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_SP_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,"*",err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_SP_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_SP_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_SP_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_sp_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_vs_c(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_VS_C",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_C")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_C",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_C")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_vs_dp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_TWO_VALUE_VS_DP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_DP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_DP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_DP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_vs_intg(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_VS_INTG",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_INTG")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_INTG",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_INTG")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_intg

  !
  !================================================================================================================================
  !
  
  SUBROUTINE write_string_two_value_vs_l(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_VS_L",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_L")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_L",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_L")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_vs_sp(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_TWO_VALUE_VS_SP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,"*",err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_SP")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_SP",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_SP")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_two_value_vs_vs(ID,FIRST_STRING,FIRST_VALUE,SECOND_STRING,SECOND_VALUE,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_TWO_VALUE_VS_VS",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_VALUE_VS_VS")
    RETURN
999 errorsexits("WRITE_STRING_TWO_VALUE_VS_VS",err,error)
!    EXITS("WRITE_STRING_TWO_VALUE_VS_VS")
    RETURN 1   
  END SUBROUTINE write_string_two_value_vs_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_c(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_C",ERR,ERROR,*999)
        
    local_string=first_string(1:len_trim(first_string))//value(1:len_trim(VALUE))
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_C",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_dp(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,format_string,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_DP",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_dp
  
  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_intg(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,format_string,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_lintg(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(LINTG), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_LINTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,format_string,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_LINTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_LINTG",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_LINTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_lintg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_l(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_L",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(VALUE,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_L",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_sp(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(VALUE,format_string,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_SP",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_value_vs(ID,FIRST_STRING,VALUE,FORMAT_STRING,ERR,ERROR,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FORMAT_STRING
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_VALUE_VS",ERR,ERROR,*999)
        
    local_string=first_string//VALUE
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_VALUE_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_VALUE_VS",err,error)
!    EXITS("WRITE_STRING_FMT_VALUE_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_value_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_C",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_DP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_INTG",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_L",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_SP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_c_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_C_VS",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_C_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_C_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_c_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_dp_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(DP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_DP_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_DP_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_DP_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_dp_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_intg_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)
   
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    INTEGER(INTG), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_INTG_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_INTG_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_INTG_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_intg_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_C",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_DP",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_INTG",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_L",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_TWO_L_INTG_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_SP",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_l_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    LOGICAL, INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_L_VS",ERR,ERROR,*999)
        
    local_string=first_string//logical_to_vstring(first_value,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_L_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_L_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_l_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_C",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
   
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_DP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_INTG",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_L",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    local_string=local_string//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING,LOCAL_STRING2

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_SP",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)
    IF(err/=0) GOTO 999
    !CPB 21/02/2007 AIX doesn't like concatenating vstrings and reassigning to itself so split this into two steps
    local_string2=local_string//second_string
    local_string=local_string2//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_sp_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    REAL(SP), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_SP_VS",ERR,ERROR,*999)
        
    local_string=first_string//number_to_vstring(first_value,first_format,err,error)//second_string//second_value
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_SP_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_SP_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_sp_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_c(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_C",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_C")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_C",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_C")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_c

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_dp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(DP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_DP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_DP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_DP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_DP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_intg(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE, &
    & second_format,err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    INTEGER(INTG), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_INTG",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_INTG")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_INTG",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_INTG")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_l(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    LOGICAL, INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_L",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//logical_to_vstring(second_value,err,error)
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_L")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_L",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_L")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_sp(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    REAL(SP), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

 !   ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_SP",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//number_to_vstring(second_value,second_format,err,error)
    IF(err/=0) GOTO 999
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_SP")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_SP",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_SP")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_fmt_two_value_vs_vs(ID,FIRST_STRING,FIRST_VALUE,FIRST_FORMAT,SECOND_STRING,SECOND_VALUE,SECOND_FORMAT, &
    & err,error,*)
    
    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_STRING
    TYPE(varying_string), INTENT(IN) :: FIRST_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_STRING
    TYPE(varying_string), INTENT(IN) :: SECOND_VALUE
    CHARACTER(LEN=*), INTENT(IN) :: SECOND_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    TYPE(varying_string) :: LOCAL_STRING

!    ENTERS("WRITE_STRING_FMT_TWO_VALUE_VS_VS",ERR,ERROR,*999)
        
    local_string=first_string//first_value//second_string//second_value
    WRITE(op_string,'(A)') char(local_string)
    CALL write_str(id,err,error,*999)
      
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_VS")
    RETURN
999 errorsexits("WRITE_STRING_FMT_TWO_VALUE_VS_VS",err,error)
!    EXITS("WRITE_STRING_FMT_TWO_VALUE_VS_VS")
    RETURN 1   
  END SUBROUTINE write_string_fmt_two_value_vs_vs

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vector_dp(ID,FIRST_IDX,DELTA,LAST_IDX,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT,REPEAT_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_IDX
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: LAST_IDX
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(DP), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,final,count

!    ENTERS("WRITE_STRING_VECTOR_DP",ERR,ERROR,*999)
        
    current=first_idx
    final=current+(number_first-1)*delta
    IF(final>last_idx) final=last_idx

    WRITE(op_string,fmt=first_format) (vector(count),count=current,final,delta)
    CALL write_str(id,err,error,*999)
    DO WHILE(final<last_idx) !more stuff to do
      current=final+delta
      final=final+number_repeat*delta
      IF(final>last_idx) final=last_idx
      WRITE(op_string,fmt=repeat_format) (vector(count),count=current,final,delta)
      CALL write_str(id,err,error,*999)
    ENDDO !final<LAST_IDX

!    EXITS("WRITE_STRING_VECTOR_DP")
    RETURN
999 errorsexits("WRITE_STRING_VECTOR_DP",err,error)
!    EXITS("WRITE_STRING_VECTOR_DP")
    RETURN 1
  END SUBROUTINE write_string_vector_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vector_intg(ID,FIRST_IDX,DELTA,LAST_IDX,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT,REPEAT_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_IDX
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: LAST_IDX
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(INTG), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,final,count

!    ENTERS("WRITE_STRING_VECTOR_INTG",ERR,ERROR,*999)
        
    current=first_idx
    final=current+(number_first-1)*delta
    IF(final>last_idx) final=last_idx
    WRITE(op_string,fmt=first_format) (vector(count),count=current,final,delta)
    CALL write_str(id,err,error,*999)
    DO WHILE(final<last_idx) !more stuff to do
      current=final+delta
      final=final+number_repeat*delta
      IF(final>last_idx) final=last_idx
      WRITE(op_string,fmt=repeat_format) (vector(count),count=current,final,delta)
      CALL write_str(id,err,error,*999)
    ENDDO !final<LAST_IDX

!    EXITS("WRITE_STRING_VECTOR_INTG")
    RETURN
999 errorsexits("WRITE_STRING_VECTOR_INTG",err,error)
!    EXITS("WRITE_STRING_VECTOR_INTG")
    RETURN 1
  END SUBROUTINE write_string_vector_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vector_lintg(ID,FIRST_IDX,DELTA,LAST_IDX,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT,REPEAT_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_IDX
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: LAST_IDX
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(LINTG), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,final,count

!    ENTERS("WRITE_STRING_VECTOR_LINTG",ERR,ERROR,*999)
        
    current=first_idx
    final=current+(number_first-1)*delta
    IF(final>last_idx) final=last_idx
    WRITE(op_string,fmt=first_format) (vector(count),count=current,final,delta)
    CALL write_str(id,err,error,*999)
    DO WHILE(final<last_idx) !more stuff to do
      current=final+delta
      final=final+number_repeat*delta
      IF(final>last_idx) final=last_idx
      WRITE(op_string,fmt=repeat_format) (vector(count),count=current,final,delta)
      CALL write_str(id,err,error,*999)
    ENDDO !final<LAST_IDX

!    EXITS("WRITE_STRING_VECTOR_LINTG")
    RETURN
999 errorsexits("WRITE_STRING_VECTOR_LINTG",err,error)
!    EXITS("WRITE_STRING_VECTOR_LINTG")
    RETURN 1
  END SUBROUTINE write_string_vector_lintg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vector_l(ID,FIRST_IDX,DELTA,LAST_IDX,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT,REPEAT_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_IDX
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: LAST_IDX
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    LOGICAL, INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,final,count

!    ENTERS("WRITE_STRING_VECTOR_L",ERR,ERROR,*999)
        
    current=first_idx
    final=current+(number_first-1)*delta
    IF(final>last_idx) final=last_idx
    WRITE(op_string,fmt=first_format) (vector(count),count=current,final,delta)
    CALL write_str(id,err,error,*999)
    DO WHILE(final<last_idx) !more stuff to do
      current=final+delta
      final=final+number_repeat*delta
      IF(final>last_idx) final=last_idx
      WRITE(op_string,fmt=repeat_format) (vector(count),count=current,final,delta)
      CALL write_str(id,err,error,*999)
    ENDDO !final<LAST_IDX

!    EXITS("WRITE_STRING_VECTOR_L")
    RETURN
999 errorsexits("WRITE_STRING_VECTOR_L",err,error)
!    EXITS("WRITE_STRING_VECTOR_L")
    RETURN 1
  END SUBROUTINE write_string_vector_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_vector_sp(ID,FIRST_IDX,DELTA,LAST_IDX,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT,REPEAT_FORMAT, &
    & err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_IDX
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: LAST_IDX
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(SP), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,final,count

!    ENTERS("WRITE_STRING_VECTOR_SP",ERR,ERROR,*999)
        
    current=first_idx
    final=current+(number_first-1)*delta
    IF(final>last_idx) final=last_idx
    WRITE(op_string,fmt=first_format) (vector(count),count=current,final,delta)
    CALL write_str(id,err,error,*999)
    DO WHILE(final<last_idx) !more stuff to do
      current=final+delta
      final=final+number_repeat*delta
      IF(final>last_idx) final=last_idx
      WRITE(op_string,fmt=repeat_format) (vector(count),count=current,final,delta)
      CALL write_str(id,err,error,*999)
    ENDDO !final<LAST_IDX

!    EXITS("WRITE_STRING_VECTOR_SP")
    RETURN
999 errorsexits("WRITE_STRING_VECTOR_SP",err,error)
!    EXITS("WRITE_STRING_VECTOR_SP")
    RETURN 1
  END SUBROUTINE write_string_vector_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_idx_vector_dp(ID,NUM_INDICES,INDICES,DELTA,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT, &
    & repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: NUM_INDICES
    INTEGER(INTG), INTENT(IN) :: INDICES(num_indices)
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(DP), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,count,number_to_do

!    ENTERS("WRITE_STRING_IDX_VECTOR_DP",ERR,ERROR,*999)
        
    number_to_do=num_indices
    WRITE(op_string,fmt=first_format) (vector((indices(count)-1)*delta+1),count=1,min(number_first,num_indices))
    CALL write_str(id,err,error,*999)
    number_to_do=num_indices-number_first
    current=number_first+1
    DO WHILE(number_to_do>0) !more stuff to do
      WRITE(op_string,fmt=repeat_format) (vector((indices(count)-1)*delta+1),count=current,min(current+number_repeat-1, &
        & num_indices))
      CALL write_str(id,err,error,*999)
      current=current+number_repeat
      number_to_do=number_to_do-number_repeat
    ENDDO !number_to_do > 0

!    EXITS("WRITE_STRING_IDX_VECTOR_DP")
    RETURN
999 errorsexits("WRITE_STRING_IDX_VECTOR_DP",err,error)
!    EXITS("WRITE_STRING_IDX_VECTOR_DP")
    RETURN 1
  END SUBROUTINE write_string_idx_vector_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_idx_vector_intg(ID,NUM_INDICES,INDICES,DELTA,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT, &
    & repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: NUM_INDICES
    INTEGER(INTG), INTENT(IN) :: INDICES(num_indices)
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(INTG), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,count,number_to_do

!    ENTERS("WRITE_STRING_IDX_VECTOR_INTG",ERR,ERROR,*999)
        
    number_to_do=num_indices
    WRITE(op_string,fmt=first_format) (vector((indices(count)-1)*delta+1),count=1,min(number_first,num_indices))
    CALL write_str(id,err,error,*999)
    number_to_do=num_indices-number_first
    current=number_first+1
    DO WHILE(number_to_do>0) !more stuff to do
      WRITE(op_string,fmt=repeat_format) (vector((indices(count)-1)*delta+1),count=current,min(current+number_repeat-1, &
        & num_indices))
      CALL write_str(id,err,error,*999)
      current=current+number_repeat
      number_to_do=number_to_do-number_repeat
    ENDDO !number_to_do > 0

!    EXITS("WRITE_STRING_IDX_VECTOR_INTG")
    RETURN
999 errorsexits("WRITE_STRING_IDX_VECTOR_INTG",err,error)
!    EXITS("WRITE_STRING_IDX_VECTOR_INTG")
    RETURN 1
  END SUBROUTINE write_string_idx_vector_intg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_idx_vector_lintg(ID,NUM_INDICES,INDICES,DELTA,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT, &
    & repeat_format,err,error,*)

    !#### Generic-Subroutine: WRITE_STRING_IDX_VECTOR_LINTG
    !###  Description:
    !###    
    !###  Parent-subroutines: WRITE_STRING_IDX_VECTOR

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: NUM_INDICES
    INTEGER(INTG), INTENT(IN) :: INDICES(num_indices)
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(LINTG), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,count,number_to_do

!    ENTERS("WRITE_STRING_IDX_VECTOR_LINTG",ERR,ERROR,*999)
        
    number_to_do=num_indices
    WRITE(op_string,fmt=first_format) (vector((indices(count)-1)*delta+1),count=1,min(number_first,num_indices))
    CALL write_str(id,err,error,*999)
    number_to_do=num_indices-number_first
    current=number_first+1
    DO WHILE(number_to_do>0) !more stuff to do
      WRITE(op_string,fmt=repeat_format) (vector((indices(count)-1)*delta+1),count=current,min(current+number_repeat-1, &
        & num_indices))
      CALL write_str(id,err,error,*999)
      current=current+number_repeat
      number_to_do=number_to_do-number_repeat
    ENDDO !number_to_do > 0

!    EXITS("WRITE_STRING_IDX_VECTOR_LINTG")
    RETURN
999 errorsexits("WRITE_STRING_IDX_VECTOR_LINTG",err,error)
!    EXITS("WRITE_STRING_IDX_VECTOR_LINTG")
    RETURN 1
  END SUBROUTINE write_string_idx_vector_lintg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_idx_vector_l(ID,NUM_INDICES,INDICES,DELTA,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT, &
    & repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: NUM_INDICES
    INTEGER(INTG), INTENT(IN) :: INDICES(num_indices)
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    LOGICAL, INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,count,number_to_do

!    ENTERS("WRITE_STRING_IDX_VECTOR_L",ERR,ERROR,*999)
        
    number_to_do=num_indices
    WRITE(op_string,fmt=first_format) (vector((indices(count)-1)*delta+1),count=1,min(number_first,num_indices))
    CALL write_str(id,err,error,*999)
    number_to_do=num_indices-number_first
    current=number_first+1
    DO WHILE(number_to_do>0) !more stuff to do
      WRITE(op_string,fmt=repeat_format) (vector((indices(count)-1)*delta+1),count=current,min(current+number_repeat-1, &
        & num_indices))
      CALL write_str(id,err,error,*999)
      current=current+number_repeat
      number_to_do=number_to_do-number_repeat
    ENDDO !number_to_do > 0

!    EXITS("WRITE_STRING_IDX_VECTOR_L")
    RETURN
999 errorsexits("WRITE_STRING_IDX_VECTOR_L",err,error)
!    EXITS("WRITE_STRING_IDX_VECTOR_L")
    RETURN 1
  END SUBROUTINE write_string_idx_vector_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_idx_vector_sp(ID,NUM_INDICES,INDICES,DELTA,NUMBER_FIRST,NUMBER_REPEAT,VECTOR,FIRST_FORMAT, &
    & repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: NUM_INDICES
    INTEGER(INTG), INTENT(IN) :: INDICES(num_indices)
    INTEGER(INTG), INTENT(IN) :: DELTA
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(SP), INTENT(IN) :: VECTOR(:)
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current,count,number_to_do

!    ENTERS("WRITE_STRING_IDX_VECTOR_SP",ERR,ERROR,*999)
        
    number_to_do=num_indices
    WRITE(op_string,fmt=first_format) (vector((indices(count)-1)*delta+1),count=1,min(number_first,num_indices))
    CALL write_str(id,err,error,*999)
    number_to_do=num_indices-number_first
    current=number_first+1
    DO WHILE(number_to_do>0) !more stuff to do
      WRITE(op_string,fmt=repeat_format) (vector((indices(count)-1)*delta+1),count=current,min(current+number_repeat-1, &
        & num_indices))
      CALL write_str(id,err,error,*999)
      current=current+number_repeat
      number_to_do=number_to_do-number_repeat
    ENDDO !number_to_do > 0

!    EXITS("WRITE_STRING_IDX_VECTOR_SP")
    RETURN
999 errorsexits("WRITE_STRING_IDX_VECTOR_SP",err,error)
!    EXITS("WRITE_STRING_IDX_VECTOR_SP")
    RETURN 1
  END SUBROUTINE write_string_idx_vector_sp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_matrix_dp(ID,FIRST_ROW,DELTA_ROW,LAST_ROW,FIRST_COLUMN,DELTA_COLUMN,LAST_COLUMN,NUMBER_FIRST, &
    & number_repeat,matrix,index_format_type,matrix_name_format,row_index_format,first_format,repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_ROW
    INTEGER(INTG), INTENT(IN) :: DELTA_ROW
    INTEGER(INTG), INTENT(IN) :: LAST_ROW
    INTEGER(INTG), INTENT(IN) :: FIRST_COLUMN
    INTEGER(INTG), INTENT(IN) :: DELTA_COLUMN
    INTEGER(INTG), INTENT(IN) :: LAST_COLUMN
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(DP), INTENT(IN) :: MATRIX(:,:)
    INTEGER(INTG), INTENT(IN) :: INDEX_FORMAT_TYPE
    CHARACTER(LEN=*), INTENT(IN) :: MATRIX_NAME_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: ROW_INDEX_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current_row,current_column,final_column,count
    CHARACTER(LEN=MAXSTRLEN) :: FORMAT_STR

!    ENTERS("WRITE_STRING_MATRIX_DP",ERR,ERROR,*999)

    IF(index_format_type==write_string_matrix_name_only) THEN
      format_str=matrix_name_format//first_format
    ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
      format_str=matrix_name_format//row_index_format//first_format
    ELSE
      CALL flagerror("Invalid index format type",err,error,*999)
    ENDIF
    DO current_row=first_row,last_row,delta_row
      current_column=first_column
      final_column=current_column+(number_first-1)*delta_column
      IF(final_column>last_column) final_column=last_column
      IF(index_format_type==write_string_matrix_name_only) THEN
        WRITE(op_string,fmt=format_str) (matrix(current_row,count),count=current_column,final_column,delta_column)
      ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
        WRITE(op_string,fmt=format_str) current_row,(matrix(current_row,count),count=current_column,final_column,delta_column)
      ENDIF
      CALL write_str(id,err,error,*999)
      DO WHILE(final_column<last_column) !more stuff to do
        current_column=final_column+delta_column
        final_column=final_column+number_repeat*delta_column
        IF(final_column>last_column) final_column=last_column
        WRITE(op_string,fmt=repeat_format) (matrix(current_row,count),count=current_column,final_column,delta_column)
        CALL write_str(id,err,error,*999)
      ENDDO !final_columnn<LAST_COLUMN
    ENDDO !current_row
    
!    EXITS("WRITE_STRING_MATRIX_DP")
    RETURN
999 errorsexits("WRITE_STRING_MATRIX_DP",err,error)
!    EXITS("WRITE_STRING_MATRIX_DP")
    RETURN 1
  END SUBROUTINE write_string_matrix_dp

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_matrix_intg(ID,FIRST_ROW,DELTA_ROW,LAST_ROW,FIRST_COLUMN,DELTA_COLUMN,LAST_COLUMN,NUMBER_FIRST, &
    & number_repeat,matrix,index_format_type,matrix_name_format,row_index_format,first_format,repeat_format,err,error,*)

    !#### Generic-Subroutine: WRITE_STRING_MATRIX_INTG
    !###  Description:
    !###    
    !###  Parent-subroutines: WRITE_STRING_MATRIX

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_ROW
    INTEGER(INTG), INTENT(IN) :: DELTA_ROW
    INTEGER(INTG), INTENT(IN) :: LAST_ROW
    INTEGER(INTG), INTENT(IN) :: FIRST_COLUMN
    INTEGER(INTG), INTENT(IN) :: DELTA_COLUMN
    INTEGER(INTG), INTENT(IN) :: LAST_COLUMN
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(INTG), INTENT(IN) :: MATRIX(:,:)
    INTEGER(INTG), INTENT(IN) :: INDEX_FORMAT_TYPE
    CHARACTER(LEN=*), INTENT(IN) :: MATRIX_NAME_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: ROW_INDEX_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current_row,current_column,final_column,count
    CHARACTER(LEN=MAXSTRLEN) :: FORMAT_STR

!    ENTERS("WRITE_STRING_MATRIX_INTG",ERR,ERROR,*999)

    IF(index_format_type==write_string_matrix_name_only) THEN
      format_str=matrix_name_format//first_format
    ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
      format_str=matrix_name_format//row_index_format//first_format
    ELSE
      CALL flagerror("Invalid index format type",err,error,*999)
    ENDIF
    DO current_row=first_row,last_row,delta_row
      current_column=first_column
      final_column=current_column+(number_first-1)*delta_column
      IF(final_column>last_column) final_column=last_column
      IF(index_format_type==write_string_matrix_name_only) THEN
        WRITE(op_string,fmt=format_str) (matrix(current_row,count),count=current_column,final_column,delta_column)
      ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
        WRITE(op_string,fmt=format_str) current_row,(matrix(current_row,count),count=current_column,final_column,delta_column)
      ENDIF
      CALL write_str(id,err,error,*999)
      DO WHILE(final_column<last_column) !more stuff to do
        current_column=final_column+delta_column
        final_column=final_column+number_repeat*delta_column
        IF(final_column>last_column) final_column=last_column
        WRITE(op_string,fmt=repeat_format) (matrix(current_row,count),count=current_column,final_column,delta_column)
        CALL write_str(id,err,error,*999)
      ENDDO !final_columnn<LAST_COLUMN
    ENDDO !current_row
    
!    EXITS("WRITE_STRING_MATRIX_INTG")
    RETURN
999 errorsexits("WRITE_STRING_MATRIX_INTG",err,error)
!    EXITS("WRITE_STRING_MATRIX_INTG")
    RETURN 1
  END SUBROUTINE write_string_matrix_intg

  !
  !================================================================================================================================
  !


  SUBROUTINE write_string_matrix_lintg(ID,FIRST_ROW,DELTA_ROW,LAST_ROW,FIRST_COLUMN,DELTA_COLUMN,LAST_COLUMN,NUMBER_FIRST, &
    & number_repeat,matrix,index_format_type,matrix_name_format,row_index_format,first_format,repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_ROW
    INTEGER(INTG), INTENT(IN) :: DELTA_ROW
    INTEGER(INTG), INTENT(IN) :: LAST_ROW
    INTEGER(INTG), INTENT(IN) :: FIRST_COLUMN
    INTEGER(INTG), INTENT(IN) :: DELTA_COLUMN
    INTEGER(INTG), INTENT(IN) :: LAST_COLUMN
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    INTEGER(LINTG), INTENT(IN) :: MATRIX(:,:)
    INTEGER(INTG), INTENT(IN) :: INDEX_FORMAT_TYPE
    CHARACTER(LEN=*), INTENT(IN) :: MATRIX_NAME_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: ROW_INDEX_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current_row,current_column,final_column,count
    CHARACTER(LEN=MAXSTRLEN) :: FORMAT_STR

!    ENTERS("WRITE_STRING_MATRIX_LINTG",ERR,ERROR,*999)

    IF(index_format_type==write_string_matrix_name_only) THEN
      format_str=matrix_name_format//first_format
    ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
      format_str=matrix_name_format//row_index_format//first_format
    ELSE
      CALL flagerror("Invalid index format type",err,error,*999)
    ENDIF
    DO current_row=first_row,last_row,delta_row
      current_column=first_column
      final_column=current_column+(number_first-1)*delta_column
      IF(final_column>last_column) final_column=last_column
      IF(index_format_type==write_string_matrix_name_only) THEN
        WRITE(op_string,fmt=format_str) (matrix(current_row,count),count=current_column,final_column,delta_column)
      ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
        WRITE(op_string,fmt=format_str) current_row,(matrix(current_row,count),count=current_column,final_column,delta_column)
      ENDIF
      CALL write_str(id,err,error,*999)
      DO WHILE(final_column<last_column) !more stuff to do
        current_column=final_column+delta_column
        final_column=final_column+number_repeat*delta_column
        IF(final_column>last_column) final_column=last_column
        WRITE(op_string,fmt=repeat_format) (matrix(current_row,count),count=current_column,final_column,delta_column)
        CALL write_str(id,err,error,*999)
      ENDDO !final_columnn<LAST_COLUMN
    ENDDO !current_row
    
!    EXITS("WRITE_STRING_MATRIX_LINTG")
    RETURN
999 errorsexits("WRITE_STRING_MATRIX_LINTG",err,error)
!    EXITS("WRITE_STRING_MATRIX_LINTG")
    RETURN 1
  END SUBROUTINE write_string_matrix_lintg

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_matrix_l(ID,FIRST_ROW,DELTA_ROW,LAST_ROW,FIRST_COLUMN,DELTA_COLUMN,LAST_COLUMN,NUMBER_FIRST, &
    & number_repeat,matrix,index_format_type,matrix_name_format,row_index_format,first_format,repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_ROW
    INTEGER(INTG), INTENT(IN) :: DELTA_ROW
    INTEGER(INTG), INTENT(IN) :: LAST_ROW
    INTEGER(INTG), INTENT(IN) :: FIRST_COLUMN
    INTEGER(INTG), INTENT(IN) :: DELTA_COLUMN
    INTEGER(INTG), INTENT(IN) :: LAST_COLUMN
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    LOGICAL, INTENT(IN) :: MATRIX(:,:)
    INTEGER(INTG), INTENT(IN) :: INDEX_FORMAT_TYPE
    CHARACTER(LEN=*), INTENT(IN) :: MATRIX_NAME_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: ROW_INDEX_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current_row,current_column,final_column,count
    CHARACTER(LEN=MAXSTRLEN) :: FORMAT_STR

!    ENTERS("WRITE_STRING_MATRIX_L",ERR,ERROR,*999)

    IF(index_format_type==write_string_matrix_name_only) THEN
      format_str=matrix_name_format//first_format
    ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
      format_str=matrix_name_format//row_index_format//first_format
    ELSE
      CALL flagerror("Invalid index format type",err,error,*999)
    ENDIF
    DO current_row=first_row,last_row,delta_row
      current_column=first_column
      final_column=current_column+(number_first-1)*delta_column
      IF(final_column>last_column) final_column=last_column
      IF(index_format_type==write_string_matrix_name_only) THEN
        WRITE(op_string,fmt=format_str) (matrix(current_row,count),count=current_column,final_column,delta_column)
      ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
        WRITE(op_string,fmt=format_str) current_row,(matrix(current_row,count),count=current_column,final_column,delta_column)
      ENDIF
      CALL write_str(id,err,error,*999)
      DO WHILE(final_column<last_column) !more stuff to do
        current_column=final_column+delta_column
        final_column=final_column+number_repeat*delta_column
        IF(final_column>last_column) final_column=last_column
        WRITE(op_string,fmt=repeat_format) (matrix(current_row,count),count=current_column,final_column,delta_column)
        CALL write_str(id,err,error,*999)
      ENDDO !final_columnn<LAST_COLUMN
    ENDDO !current_row
    
!    EXITS("WRITE_STRING_MATRIX_L")
    RETURN
999 errorsexits("WRITE_STRING_MATRIX_L",err,error)
!    EXITS("WRITE_STRING_MATRIX_L")
    RETURN 1
  END SUBROUTINE write_string_matrix_l

  !
  !================================================================================================================================
  !

  SUBROUTINE write_string_matrix_sp(ID,FIRST_ROW,DELTA_ROW,LAST_ROW,FIRST_COLUMN,DELTA_COLUMN,LAST_COLUMN,NUMBER_FIRST, &
    & number_repeat,matrix,index_format_type,matrix_name_format,row_index_format,first_format,repeat_format,err,error,*)

    !Argument variables
    INTEGER(INTG), INTENT(IN) :: ID
    INTEGER(INTG), INTENT(IN) :: FIRST_ROW
    INTEGER(INTG), INTENT(IN) :: DELTA_ROW
    INTEGER(INTG), INTENT(IN) :: LAST_ROW
    INTEGER(INTG), INTENT(IN) :: FIRST_COLUMN
    INTEGER(INTG), INTENT(IN) :: DELTA_COLUMN
    INTEGER(INTG), INTENT(IN) :: LAST_COLUMN
    INTEGER(INTG), INTENT(IN) :: NUMBER_FIRST
    INTEGER(INTG), INTENT(IN) :: NUMBER_REPEAT
    REAL(SP), INTENT(IN) :: MATRIX(:,:)
    INTEGER(INTG), INTENT(IN) :: INDEX_FORMAT_TYPE
    CHARACTER(LEN=*), INTENT(IN) :: MATRIX_NAME_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: ROW_INDEX_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: FIRST_FORMAT
    CHARACTER(LEN=*), INTENT(IN) :: REPEAT_FORMAT
    INTEGER(INTG), INTENT(OUT) :: ERR
    TYPE(varying_string), INTENT(OUT) :: ERROR
    !Local variables
    INTEGER(INTG) ::  current_row,current_column,final_column,count
    CHARACTER(LEN=MAXSTRLEN) :: FORMAT_STR

!    ENTERS("WRITE_STRING_MATRIX_SP",ERR,ERROR,*999)

    IF(index_format_type==write_string_matrix_name_only) THEN
      format_str=matrix_name_format//first_format
    ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
      format_str=matrix_name_format//row_index_format//first_format
    ELSE
      CALL flagerror("Invalid index format type",err,error,*999)
    ENDIF
    DO current_row=first_row,last_row,delta_row
      current_column=first_column
      final_column=current_column+(number_first-1)*delta_column
      IF(final_column>last_column) final_column=last_column
      IF(index_format_type==write_string_matrix_name_only) THEN
        WRITE(op_string,fmt=format_str) (matrix(current_row,count),count=current_column,final_column,delta_column)
      ELSE IF(index_format_type==write_string_matrix_name_and_indices) THEN
        WRITE(op_string,fmt=format_str) current_row,(matrix(current_row,count),count=current_column,final_column,delta_column)
      ENDIF
      CALL write_str(id,err,error,*999)
      DO WHILE(final_column<last_column) !more stuff to do
        current_column=final_column+delta_column
        final_column=final_column+number_repeat*delta_column
        IF(final_column>last_column) final_column=last_column
        WRITE(op_string,fmt=repeat_format) (matrix(current_row,count),count=current_column,final_column,delta_column)
        CALL write_str(id,err,error,*999)
      ENDDO !final_columnn<LAST_COLUMN
    ENDDO !current_row
    
!    EXITS("WRITE_STRING_MATRIX_SP")
    RETURN
999 errorsexits("WRITE_STRING_MATRIX_SP",err,error)
    RETURN 1
  END SUBROUTINE write_string_matrix_sp

  !
  !================================================================================================================================
  !

END MODULE input_output