gtool_history_generic.f90

Go to the documentation of this file.

!--
! *** Caution!! ***
!
! This file is generated from "gtool_history_generic.rb2f90" by Ruby 3.3.8.
! Please do not edit this file directly.
!
! [JAPANESE]
!
! ※※※ 注意!!! ※※※
!
! このファイルは "gtool_history_generic.rb2f90" から Ruby 3.3.8
! によって自動生成されたファイルです.
! このファイルを直接編集しませんようお願い致します.
!
!
!++
!> @file gtool_history_generic.f90
!>
!> @author Yasuhiro MORIKAWA, Eizi TOYODA
!> @copyright Copyright (C) GFD Dennou Club, 2000-2026. All rights reserved. <br/>
!>            License is BSD-2-Clause. See [COPYRIGHT](@ref COPYRIGHT) in detail
!>
!> @en
!> @brief Interfaces of procedures provided from "gtool_history"
!> @enden
!>
!> @ja
!> @brief gtool_history より提供される手続の引用仕様宣言
!> @endja
 
module gtool_history_generic
  !> @en
  !> Interfaces of procedures provided from "gtool_history".
  !>
  !> See gtool_history for brief and usage of this module.
  !>
  !> ### Procedures List
  !>
  !> **For Output:**
  !>
  !> - HistoryCreate       : Initialization of gtool4 data output
  !> - HistoryAddVariable  : Variable definition
  !> - HistoryCopyVariable : Variable definition (copy from another file)
  !> - HistoryPut          : Data output
  !> - HistoryAddAttr      : Add attribute to variable
  !> - HistoryClose        : Finalization
  !> - HistorySetTime      : Set time
  !> - HistoryPutAxisMPI   : Set axis data for entire domain (only valid with MPI)
  !>
  !> **For Input:**
  !>
  !> - HistoryGet          : Data input (for fixed-length arrays)
  !> - HistoryGetPointer   : Data input (for pointer arrays)
  !> - HistoryGetAttr      : Attribute input
  !>
  !> **Others:**
  !>
  !> - HistoryInquire      : Inquire gtool_history_types::GT_HISTORY type variable
  !> - HistoryCopy         : Copy gtool_history_types::GT_HISTORY type variable
  !> - HistoryPutLine      : Print gtool_history_types::GT_HISTORY type variable
  !> - HistoryInitialized  : Check initialization of gtool_history_types::GT_HISTORY type variable
  !>
  !> **gtool_history_types::GT_HISTORY_AXIS related:**
  !>
  !> - HistoryAxisCreate     : Create (initialization)
  !> - HistoryAxisCopy       : Copy
  !> - HistoryAxisAddAttr    : Add attribute
  !> - HistoryAxisInquire    : Inquire
  !> - HistoryAxisClear      : Clear (finalization)
  !>
  !> **gtool_history_types::GT_HISTORY_VARINFO related:**
  !>
  !> - HistoryVarinfoCreate      : Create (initialization)
  !> - HistoryVarinfoCopy        : Copy
  !> - HistoryVarinfoAddAttr     : Add attribute
  !> - HistoryVarinfoInquire     : Inquire
  !> - HistoryVarinfoClear       : Clear (finalization)
  !> - HistoryVarinfoInitialized : Check initialization
  !> @enden
  !>
  !> @ja
  !> gtool_history より提供される手続の引用仕様宣言.
  !>
  !> モジュールの概要や使用方法については, gtool_history を参照ください.
  !>
  !> ### 手続一覧
  !>
  !> **出力用:**
  !>
  !> - HistoryCreate       : gtool4 データ出力用初期設定
  !> - HistoryAddVariable  : 変数定義
  !> - HistoryCopyVariable : 変数定義 (別ファイルの変数コピー)
  !> - HistoryPut          : データ出力
  !> - HistoryAddAttr      : 変数に属性付加
  !> - HistoryClose        : 終了処理
  !> - HistorySetTime      : 時刻指定
  !> - HistoryPutAxisMPI   : 領域全体の座標データ指定 (MPI 使用時のみ有効)
  !>
  !> **入力用:**
  !>
  !> - HistoryGet          : データ入力 (固定長配列用)
  !> - HistoryGetPointer   : データ入力 (ポインタ配列用)
  !> - HistoryGetAttr      : 属性入力
  !>
  !> **その他:**
  !>
  !> - HistoryInquire      : gtool_history_types::GT_HISTORY 型変数への問い合わせ
  !> - HistoryCopy         : gtool_history_types::GT_HISTORY 型変数のコピー
  !> - HistoryPutLine      : gtool_history_types::GT_HISTORY 型変数の印字
  !> - HistoryInitialized  : gtool_history_types::GT_HISTORY 型変数の初期設定をチェック
  !>
  !> **gtool_history_types::GT_HISTORY_AXIS 関連:**
  !>
  !> - HistoryAxisCreate     : 作成 (初期設定)
  !> - HistoryAxisCopy       : コピー
  !> - HistoryAxisAddAttr    : 属性付加
  !> - HistoryAxisInquire    : 問い合わせ
  !> - HistoryAxisClear      : 終了処理
  !>
  !> **gtool_history_types::GT_HISTORY_VARINFO 関連:**
  !>
  !> - HistoryVarinfoCreate      : 作成 (初期設定)
  !> - HistoryVarinfoCopy        : コピー
  !> - HistoryVarinfoAddAttr     : 属性付加
  !> - HistoryVarinfoInquire     : 問い合わせ
  !> - HistoryVarinfoClear       : 終了処理
  !> - HistoryVarinfoInitialized : 初期設定チェック
  !> @endja
 
  use gtdata_types, only: gt_variable
  use dc_types, only: string, token, dp, stderr
  use dc_trace, only: beginsub, endsub, dbgmessage
  use dc_date_types, only: dc_difftime, unit_symbol_err
  implicit none
 
  private
  public:: historyinitialized
  public:: create, copy, Inquire, put_attr
  public:: historycreate, historyclose, historyaxisclear, historyvarinfoclear
  public:: historyaxiscreate
  public:: historyvarinfocreate
  public:: historyinquire, historyaxisinquire, historyvarinfoinquire
  public:: historycopy, historyaxiscopy, historyvarinfocopy, historyvarinfoinitialized
  public:: historyputline
  public:: historyaddvariable, historycopyvariable
  public:: historyput
  public:: historyaddattr, historyaxisaddattr, historyvarinfoaddattr
  public:: historysettime
  public:: historyget, historygetpointer
  public:: historygetattr
  public:: historyputaxismpi
 
  public:: initialized
                    ! 後方互換用.
                    ! For backward compatibility.
 
  interface initialized
    logical function historyinitialized1( history ) result(result)
      use gtool_history_types, only: gt_history
      type(gt_history), intent(in):: history
    end function historyinitialized1
  end interface
 
  interface historyinitialized
    logical function historyinitialized0( history ) result(result)
      use gtool_history_types, only: gt_history
      type(gt_history), intent(in):: history
    end function historyinitialized0
  end interface
 
  interface historycreate
    subroutine historycreate1( &
      & file, title, source, institution, &
      & dims, dimsizes, longnames, units, origin, interval, &
      & xtypes, history, origind, intervald, conventions, gt_version, overwrite, quiet, &
      & flag_mpi_gather, flag_mpi_split, err )  !:doc-priority 20:
 
      use gtool_history_types, only: gt_history
      use dc_types, only: dp
      character(*), intent(in):: file, title, source, institution, dims(:)
      integer, intent(in):: dimsizes (:)
      character(*), intent(in):: longnames (:)
      character(*), intent(in):: units(:)
      real, intent(in), optional:: origin, interval
      character(*), intent(in),  optional:: xtypes(:)
      type(gt_history), intent(out), optional, target:: history
      real(DP), intent(in), optional:: origind, intervald
      character(*), intent(in), optional:: conventions, gt_version
      logical, intent(in), optional:: overwrite, quiet, flag_mpi_gather, flag_mpi_split
      logical, intent(out), optional:: err
    end subroutine historycreate1
 
    subroutine historycreate2( &
      & file, title, source, institution, &
      & dims, dimsizes, longnames, units, origin, interval, &
      & xtypes, history, conventions, gt_version, overwrite, quiet, &
      & flag_mpi_gather, flag_mpi_split, err ) !:doc-priority 40:
 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      character(*), intent(in):: file, title, source, institution, dims(:)
      integer, intent(in):: dimsizes (:)
      character(*), intent(in):: longnames (:)
      character(*), intent(in):: units(:)
      type(dc_difftime), intent(in):: origin
      type(dc_difftime), intent(in), optional:: interval
      character(*), intent(in),  optional:: xtypes(:)
      type(gt_history), intent(out), optional, target:: history
      character(*), intent(in), optional:: conventions, gt_version
      logical, intent(in), optional:: overwrite, quiet, flag_mpi_gather, flag_mpi_split
      logical, intent(out), optional:: err
    end subroutine historycreate2
 
    subroutine historycreate3(file, title, source, institution, &
      & axes, origin, interval, history, origind, intervald, conventions, gt_version, &
      & overwrite, quiet, flag_mpi_gather, flag_mpi_split, err ) !:doc-priority 30:
      use gtool_history_types, only: gt_history, gt_history_axis
      use dc_types, only: dp
      character(*), intent(in):: file, title, source, institution
      type(gt_history_axis), intent(in):: axes(:)
      real, intent(in), optional:: origin, interval
      type(gt_history), intent(out), optional, target:: history
      real(DP), intent(in), optional:: origind, intervald
      character(*), intent(in), optional:: conventions, gt_version
      logical, intent(in), optional:: overwrite, quiet, flag_mpi_gather, flag_mpi_split
      logical, intent(out), optional:: err
    end subroutine historycreate3
 
  end interface
 
  interface historyaxiscreate
    subroutine historyaxiscreate1( axis, &
      & name, size, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(out) :: axis
      character(*) , intent(in):: name     ! 次元変数名
      integer, intent(in):: size     ! 次元長 (配列サイズ)
      character(*) , intent(in):: longname ! 次元変数の記述的名称
      character(*) , intent(in):: units    ! 次元変数の単位
      character(*) , intent(in):: xtype    ! 次元変数の型
    end subroutine historyaxiscreate1
  end interface
 
  interface historyvarinfocreate
    subroutine historyvarinfocreate1( varinfo, & ! (out)
      & name, dims, longname, units, xtype, &    ! (in)
      & time_average, average, err &            ! (in) optional
      & )
      use gtool_history_types, only: gt_history_varinfo
      implicit none
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: name     ! 変数名
      character(*), intent(in):: dims(:)  ! 依存する次元
      character(*), intent(in):: longname ! 変数の記述的名称
      character(*), intent(in):: units    ! 変数の単位
      character(*), intent(in), optional:: xtype
                                           ! 変数の型
      logical, intent(in), optional:: time_average
                                           ! 時間平均
      logical, intent(in), optional:: average
                                           ! 時間平均 (後方互換用)
      logical, intent(out), optional:: err
    end subroutine historyvarinfocreate1
  end interface
 
  interface create
    subroutine historyaxiscreate2( axis, &
      & name, size, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(out) :: axis
      character(*) , intent(in):: name     ! 次元変数名
      integer, intent(in):: size     ! 次元長 (配列サイズ)
      character(*) , intent(in):: longname ! 次元変数の記述的名称
      character(*) , intent(in):: units    ! 次元変数の単位
      character(*) , intent(in):: xtype    ! 次元変数の型
    end subroutine historyaxiscreate2
 
    subroutine historyvarinfocreate2( varinfo, & ! (out)
      & name, dims, longname, units, xtype, &    ! (in)
      & time_average, average, err &            ! (in) optional
      & )
      use gtool_history_types, only: gt_history_varinfo
      implicit none
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: name     ! 変数名
      character(*), intent(in):: dims(:)  ! 依存する次元
      character(*), intent(in):: longname ! 変数の記述的名称
      character(*), intent(in):: units    ! 変数の単位
      character(*), intent(in), optional:: xtype
                                           ! 変数の型
      logical, intent(in), optional:: time_average
                                           ! 時間平均
      logical, intent(in), optional:: average
                                           ! 時間平均 (後方互換用)
      logical, intent(out), optional:: err
    end subroutine historyvarinfocreate2
  end interface
 
  interface historyaddvariable
    recursive subroutine historyaddvariable1( &
      & varname, dims, longname, units, &
      & xtype, time_average, average, history, err )
      use gtool_history_types, only: gt_history
      character(len = *), intent(in):: varname, dims(:), longname, units
      character(len = *), intent(in), optional:: xtype
      logical, intent(in), optional:: time_average, average
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(out), optional:: err
    end subroutine historyaddvariable1
 
    subroutine historyaddvariable2( &
      & varinfo, history, err )
      use gtool_history_types, only: gt_history, gt_history_varinfo
      type(gt_history_varinfo), intent(in)             :: varinfo
      type(gt_history),         intent(inout), optional:: history
      logical, intent(out), optional:: err
    end subroutine historyaddvariable2
  end interface
 
  interface historycopy
    subroutine historycopy1(hist_dest, file, hist_src, &
      & title, source, institution, &
      & origin, interval, &
      & conventions, gt_version)
      use gtool_history_types, only: gt_history
      type(gt_history), intent(out), target:: hist_dest
      character(*), intent(in):: file
      type(gt_history), intent(in), optional, target:: hist_src
      character(*), intent(in), optional:: title, source, institution
      real, intent(in), optional:: origin, interval
      character(*), intent(in), optional:: conventions, gt_version
    end subroutine historycopy1
  end interface
 
  interface historyaxiscopy
    subroutine historyaxiscopy1(axis_dest, axis_src, err, &
      & name, length, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(out) :: axis_dest ! コピー先 GT_HISTORY_AXIS
      type(gt_history_axis),intent(in)  :: axis_src  ! コピー元 GT_HISTORY_AXIS
      logical, intent(out), optional :: err
      character(*) , intent(in), optional:: name     ! 次元変数名
      integer, intent(in), optional:: length         ! 次元長 (配列サイズ)
      character(*) , intent(in), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(in), optional:: units    ! 次元変数の単位
      character(*) , intent(in), optional:: xtype    ! 次元変数の型
    end subroutine historyaxiscopy1
  end interface
 
  interface historyvarinfocopy
    subroutine historyvarinfocopy1(varinfo_dest, varinfo_src, err, &
      & name, dims, longname, units, xtype )
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(out):: varinfo_dest
      type(gt_history_varinfo),intent(in):: varinfo_src
      logical, intent(out), optional:: err
      character(*) , intent(in), optional:: name     ! 次元変数名
      character(*) , intent(in), optional, target:: dims(:)  ! 依存する次元
      character(*) , intent(in), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(in), optional:: units    ! 次元変数の単位
      character(*) , intent(in), optional:: xtype    ! 次元変数の型
    end subroutine historyvarinfocopy1
  end interface
 
  interface copy
    subroutine historycopy2(hist_dest, file, hist_src, &
      & title, source, institution, &
      & origin, interval, &
      & conventions, gt_version)
      use gtool_history_types, only: gt_history
      type(gt_history), intent(out), target:: hist_dest
      character(*), intent(in):: file
      type(gt_history), intent(in), optional, target:: hist_src
      character(*), intent(in), optional:: title, source, institution
      real, intent(in), optional:: origin, interval
      character(*), intent(in), optional:: conventions, gt_version
    end subroutine historycopy2
 
    subroutine historyaxiscopy2(axis_dest, axis_src, err, &
      & name, length, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(out) :: axis_dest ! コピー先 GT_HISTORY_AXIS
      type(gt_history_axis),intent(in)  :: axis_src  ! コピー元 GT_HISTORY_AXIS
      logical, intent(out), optional :: err
      character(*) , intent(in), optional:: name     ! 次元変数名
      integer, intent(in), optional:: length         ! 次元長 (配列サイズ)
      character(*) , intent(in), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(in), optional:: units    ! 次元変数の単位
      character(*) , intent(in), optional:: xtype    ! 次元変数の型
    end subroutine historyaxiscopy2
 
    subroutine historyvarinfocopy2(varinfo_dest, varinfo_src, err, &
      & name, dims, longname, units, xtype )
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(out):: varinfo_dest
      type(gt_history_varinfo),intent(in):: varinfo_src
      logical, intent(out), optional:: err
      character(*) , intent(in), optional:: name     ! 次元変数名
      character(*) , intent(in), optional, target:: dims(:)  ! 依存する次元
      character(*) , intent(in), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(in), optional:: units    ! 次元変数の単位
      character(*) , intent(in), optional:: xtype    ! 次元変数の型
    end subroutine historyvarinfocopy2
  end interface
 
  interface historycopyvariable
    subroutine historycopyvariable1(file, varname, history, overwrite)
      use gtool_history_types, only: gt_history
      character(len = *), intent(in):: file, varname
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(in), optional:: overwrite
    end subroutine historycopyvariable1
  end interface
 
  interface historyinquire
    subroutine historyinquire1(history, err, file, title, source, &
      & dims, dimsizes, longnames, units, xtypes, &
      & institution, origin, interval, newest, oldest, &
      & conventions, gt_version, &
      & axes, varinfo )
      use gtool_history_types, only: gt_history, gt_history_axis, gt_history_varinfo
      type(gt_history), intent(in):: history
      logical, intent(out), optional :: err
      character(*), intent(out), optional:: file, title, source, institution
      real,intent(out), optional:: origin, interval
      real,intent(out), optional:: newest ! 最新の時刻
      real,intent(out), optional:: oldest ! 最初の時刻
      character(*), intent(out), optional:: conventions, gt_version
      character(*), pointer, optional:: dims(:) ! (out)
      integer,pointer, optional:: dimsizes(:) ! (out)
      character(*), pointer, optional:: longnames(:) ! (out)
      character(*), pointer, optional:: units(:) ! (out)
      character(*), pointer, optional:: xtypes(:) ! (out)
      type(gt_history_axis), pointer, optional :: axes(:) ! (out)
      type(gt_history_varinfo), pointer, optional :: varinfo(:) ! (out)
    end subroutine historyinquire1
 
    subroutine historyinquire2(history, err, file, title, source, &
      & dims, dimsizes, longnames, units, xtypes, &
      & institution, origin, interval, newest, oldest, &
      & conventions, gt_version, &
      & axes, varinfo )
      use gtool_history_types, only: gt_history, gt_history_axis, gt_history_varinfo
      character(*), intent(in):: history
      logical, intent(out), optional :: err
      character(*), intent(out), optional:: file, title, source, institution
      real,intent(out), optional:: origin, interval, newest, oldest
      character(*), intent(out), optional:: conventions, gt_version
      character(*), pointer, optional:: dims(:) ! (out)
      integer,pointer, optional:: dimsizes(:) ! (out)
      character(*), pointer, optional:: longnames(:) ! (out)
      character(*), pointer, optional:: units(:) ! (out)
      character(*), pointer, optional:: xtypes(:) ! (out)
      type(gt_history_axis), pointer, optional :: axes(:) ! (out)
      type(gt_history_varinfo), pointer, optional :: varinfo(:) ! (out)
    end subroutine historyinquire2
 
  end interface
 
  interface historyaxisinquire
    subroutine historyaxisinquire1( axis, &
      & name, size, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(in) :: axis
      character(*) , intent(out), optional:: name     ! 次元変数名
      integer, intent(out), optional:: size     ! 次元長 (配列サイズ)
      character(*) , intent(out), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(out), optional:: units    ! 次元変数の単位
      character(*) , intent(out), optional:: xtype    ! 次元変数の型
    end subroutine historyaxisinquire1
  end interface
 
  interface historyvarinfoinquire
    subroutine historyvarinfoinquire1( varinfo, & ! (in)
      & name, dims, longname, units, xtype, &     ! (out) optional
      & time_average, average, err )              ! (out) optional
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(in) :: varinfo
      character(*), intent(out), optional:: name     ! 変数名
      character(*), pointer,     optional:: dims(:)  !(out) 依存する次元
      character(*), intent(out), optional:: longname ! 変数の記述的名称
      character(*), intent(out), optional:: units    ! 変数の単位
      character(*), intent(out), optional:: xtype    ! 変数の型
      logical, intent(out), optional:: time_average  ! 時間平均
      logical, intent(out), optional:: average       ! 時間平均 (後方互換用)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoinquire1
  end interface
 
  interface inquire
    subroutine historyinquire3(history, err, file, title, source, &
      & dims, dimsizes, longnames, units, xtypes, &
      & institution, origin, interval, newest, oldest, &
      & conventions, gt_version, &
      & axes, varinfo )
      use gtool_history_types, only: gt_history, gt_history_axis, gt_history_varinfo
      type(gt_history), intent(in):: history
      logical, intent(out), optional :: err
      character(*), intent(out), optional:: file, title, source, institution
      real,intent(out), optional:: origin, interval
      real,intent(out), optional:: newest ! 最新の時刻
      real,intent(out), optional:: oldest ! 最初の時刻
      character(*), intent(out), optional:: conventions, gt_version
      character(*), pointer, optional:: dims(:) ! (out)
      integer,pointer, optional:: dimsizes(:) ! (out)
      character(*), pointer, optional:: longnames(:) ! (out)
      character(*), pointer, optional:: units(:) ! (out)
      character(*), pointer, optional:: xtypes(:) ! (out)
      type(gt_history_axis), pointer, optional :: axes(:) ! (out)
      type(gt_history_varinfo), pointer, optional :: varinfo(:) ! (out)
    end subroutine historyinquire3
 
    subroutine historyinquire4(history, err, file, title, source, &
      & dims, dimsizes, longnames, units, xtypes, &
      & institution, origin, interval, newest, oldest, &
      & conventions, gt_version, &
      & axes, varinfo )
      use gtool_history_types, only: gt_history_axis, gt_history_varinfo
      character(*), intent(in):: history
      logical, intent(out), optional :: err
      character(*), intent(out), optional:: file, title, source, institution
      real,intent(out), optional:: origin, interval, newest, oldest
      character(*), intent(out), optional:: conventions, gt_version
      character(*), pointer, optional:: dims(:) ! (out)
      integer,pointer, optional:: dimsizes(:) ! (out)
      character(*), pointer, optional:: longnames(:) ! (out)
      character(*), pointer, optional:: units(:) ! (out)
      character(*), pointer, optional:: xtypes(:) ! (out)
      type(gt_history_axis), pointer, optional :: axes(:) ! (out)
      type(gt_history_varinfo), pointer, optional :: varinfo(:) ! (out)
    end subroutine historyinquire4
 
    subroutine historyaxisinquire2( axis, &
      & name, size, longname, units, xtype)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(in) :: axis
      character(*) , intent(out), optional:: name     ! 次元変数名
      integer, intent(out), optional:: size     ! 次元長 (配列サイズ)
      character(*) , intent(out), optional:: longname ! 次元変数の記述的名称
      character(*) , intent(out), optional:: units    ! 次元変数の単位
      character(*) , intent(out), optional:: xtype    ! 次元変数の型
    end subroutine historyaxisinquire2
 
    subroutine historyvarinfoinquire2( varinfo, & ! (in)
      & name, dims, longname, units, xtype, &     ! (out) optional
      & time_average, average, err )              ! (out) optional
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(in) :: varinfo
      character(*), intent(out), optional:: name     ! 変数名
      character(*), pointer,     optional:: dims(:)  !(out) 依存する次元
      character(*), intent(out), optional:: longname ! 変数の記述的名称
      character(*), intent(out), optional:: units    ! 変数の単位
      character(*), intent(out), optional:: xtype    ! 変数の型
      logical, intent(out), optional:: time_average  ! 時間平均
      logical, intent(out), optional:: average       ! 時間平均 (後方互換用)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoinquire2
  end interface
 
  interface
    subroutine historyaxisclear(axis)
      use gtool_history_types, only: gt_history_axis
      type(gt_history_axis),intent(inout) :: axis
    end subroutine historyaxisclear
  end interface
 
  interface historyvarinfoclear
    subroutine historyvarinfoclear0(varinfo, err)
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(inout) :: varinfo
      logical, intent(out), optional:: err
    end subroutine historyvarinfoclear0
  end interface
 
  interface historyvarinfoinitialized
    logical function historyvarinfoinitialized0( varinfo ) result(result)
      use gtool_history_types, only: gt_history_varinfo
      type(gt_history_varinfo),intent(in) :: varinfo
    end function historyvarinfoinitialized0
  end interface
 
  interface historyputline
    subroutine historyputline( history, unit, indent, err )
      use gtool_history_types, only: gt_history
      type(gt_history), intent(in), target, optional:: history
      integer, intent(in), optional:: unit
      character(*), intent(in), optional:: indent
      logical, intent(out), optional:: err
    end subroutine historyputline
  end interface
 
  interface
    subroutine historysettime(time, history, difftime, timed)
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      real, intent(in), optional:: time
      type(gt_history), intent(inout), optional, target:: history
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
    end subroutine historysettime
  end interface
 
  interface
    subroutine historyclose( history, quiet, err )
      use gtool_history_types, only: gt_history
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(in), optional:: quiet
      logical, intent(out), optional:: err
    end subroutine historyclose
  end interface
 
  interface historyput
 
 
    subroutine historyputdouble0( varname, value, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 30: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: value
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble0
 
 
    subroutine historyputdouble1( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble1
 
 
    subroutine historyputdouble2( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble2
 
 
    subroutine historyputdouble3( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble3
 
 
    subroutine historyputdouble4( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble4
 
 
    subroutine historyputdouble5( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble5
 
 
    subroutine historyputdouble6( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble6
 
 
    subroutine historyputdouble7( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:,:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputdouble7
 
 
    subroutine historyputreal0( varname, value, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 30: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: value
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal0
 
 
    subroutine historyputreal1( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal1
 
 
    subroutine historyputreal2( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal2
 
 
    subroutine historyputreal3( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal3
 
 
    subroutine historyputreal4( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal4
 
 
    subroutine historyputreal5( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal5
 
 
    subroutine historyputreal6( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal6
 
 
    subroutine historyputreal7( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:,:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputreal7
 
 
    subroutine historyputint0( varname, value, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 30: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: value
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint0
 
 
    subroutine historyputint1( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint1
 
 
    subroutine historyputint2( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint2
 
 
    subroutine historyputint3( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint3
 
 
    subroutine historyputint4( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint4
 
 
    subroutine historyputint5( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint5
 
 
    subroutine historyputint6( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint6
 
 
    subroutine historyputint7( varname, array, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err )  !:doc-priority 40: 
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:,:,:,:,:,:,:)
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputint7
 
 
    subroutine historyputchar0( varname, value, &
      & history, range, time, quiet, &
      & difftime, timed, time_average_store, err ) !:doc-priority 35:
      use gtool_history_types, only: gt_history
      use dc_date_types, only: dc_difftime
      use dc_types, only: dp
      character(*), intent(in):: varname
      character(*), intent(in):: value
      type(gt_history), intent(inout), optional, target:: history
      character(*), intent(in), optional:: range
      real, intent(in), optional:: time
      logical, intent(in), optional:: quiet
      type(dc_difftime), intent(in), optional:: difftime
      real(DP), intent(in), optional:: timed
      logical, intent(in), optional:: time_average_store
      logical, intent(out), optional:: err
    end subroutine historyputchar0
 
  end interface
 
  interface historyputaxismpi
 
 
    subroutine historyputaxismpireal( varname, array, &
      & history, err )
      use gtool_history_types, only: gt_history
      use dc_types, only: dp
      character(*), intent(in):: varname
      real, intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(out), optional:: err
    end subroutine historyputaxismpireal
 
 
    subroutine historyputaxismpidouble( varname, array, &
      & history, err )
      use gtool_history_types, only: gt_history
      use dc_types, only: dp
      character(*), intent(in):: varname
      real(DP), intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(out), optional:: err
    end subroutine historyputaxismpidouble
 
 
    subroutine historyputaxismpiint( varname, array, &
      & history, err )
      use gtool_history_types, only: gt_history
      use dc_types, only: dp
      character(*), intent(in):: varname
      integer, intent(in):: array(:)
      type(gt_history), intent(inout), optional, target:: history
      logical, intent(out), optional:: err
    end subroutine historyputaxismpiint
 
 
  end interface
 
  interface historyaddattr
 
 
  subroutine historyaddattrchar0( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    character(*), intent(in):: value
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrchar0
 
 
  subroutine historyaddattrlogical0( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    logical, intent(in):: value
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrlogical0
 
 
  subroutine historyaddattrint0( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    integer, intent(in):: value
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrint0
 
 
  subroutine historyaddattrint1( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    integer, intent(in):: value(:)
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrint1
 
 
  subroutine historyaddattrreal0( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    real, intent(in):: value
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrreal0
 
 
  subroutine historyaddattrreal1( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    real, intent(in):: value(:)
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrreal1
 
 
  subroutine historyaddattrdouble0( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    real(DP), intent(in):: value
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrdouble0
 
 
  subroutine historyaddattrdouble1( &
    & varname, attrname, value, history, err)
    use gtool_history_types, only: gt_history
    use dc_types, only: dp
    character(*), intent(in):: varname
    character(*), intent(in):: attrname
    real(DP), intent(in):: value(:)
    type(gt_history), intent(inout), target, optional:: history
    logical, intent(out), optional:: err
  end subroutine historyaddattrdouble1
 
 
  end interface
 
  interface historyaxisaddattr
 
 
    subroutine historyaxisaddattrchar0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      character(*), intent(in):: value
    end subroutine historyaxisaddattrchar0
 
 
    subroutine historyaxisaddattrlogical0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      logical, intent(in):: value
    end subroutine historyaxisaddattrlogical0
 
 
    subroutine historyaxisaddattrint0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value
    end subroutine historyaxisaddattrint0
 
 
    subroutine historyaxisaddattrint1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value(:)
    end subroutine historyaxisaddattrint1
 
 
    subroutine historyaxisaddattrreal0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value
    end subroutine historyaxisaddattrreal0
 
 
    subroutine historyaxisaddattrreal1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value(:)
    end subroutine historyaxisaddattrreal1
 
 
    subroutine historyaxisaddattrdouble0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value
    end subroutine historyaxisaddattrdouble0
 
 
    subroutine historyaxisaddattrdouble1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value(:)
    end subroutine historyaxisaddattrdouble1
 
 
  end interface
 
  interface historyvarinfoaddattr
 
 
    subroutine historyvarinfoaddattrchar0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      character(*), intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrchar0
 
 
    subroutine historyvarinfoaddattrlogical0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      logical, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrlogical0
 
 
    subroutine historyvarinfoaddattrint0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrint0
 
 
    subroutine historyvarinfoaddattrint1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrint1
 
 
    subroutine historyvarinfoaddattrreal0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrreal0
 
 
    subroutine historyvarinfoaddattrreal1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrreal1
 
 
    subroutine historyvarinfoaddattrdouble0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrdouble0
 
 
    subroutine historyvarinfoaddattrdouble1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattrdouble1
 
 
  end interface
 
  interface put_attr
 
 
    subroutine historyaxisaddattr2char0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      character(*), intent(in):: value
    end subroutine historyaxisaddattr2char0
 
    subroutine historyvarinfoaddattr2char0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      character(*), intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2char0
 
 
    subroutine historyaxisaddattr2logical0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      logical, intent(in):: value
    end subroutine historyaxisaddattr2logical0
 
    subroutine historyvarinfoaddattr2logical0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      logical, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2logical0
 
 
    subroutine historyaxisaddattr2int0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value
    end subroutine historyaxisaddattr2int0
 
    subroutine historyvarinfoaddattr2int0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2int0
 
 
    subroutine historyaxisaddattr2int1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value(:)
    end subroutine historyaxisaddattr2int1
 
    subroutine historyvarinfoaddattr2int1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      integer, intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2int1
 
 
    subroutine historyaxisaddattr2real0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value
    end subroutine historyaxisaddattr2real0
 
    subroutine historyvarinfoaddattr2real0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2real0
 
 
    subroutine historyaxisaddattr2real1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value(:)
    end subroutine historyaxisaddattr2real1
 
    subroutine historyvarinfoaddattr2real1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real, intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2real1
 
 
    subroutine historyaxisaddattr2double0( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value
    end subroutine historyaxisaddattr2double0
 
    subroutine historyvarinfoaddattr2double0( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2double0
 
 
    subroutine historyaxisaddattr2double1( &
      & axis, attrname, value)
      use gtool_history_types, only: gt_history_axis
      use dc_types, only: dp
      type(gt_history_axis),intent(inout) :: axis
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value(:)
    end subroutine historyaxisaddattr2double1
 
    subroutine historyvarinfoaddattr2double1( &
      & varinfo, attrname, value, err )
      use gtool_history_types, only: gt_history_varinfo
      use dc_types, only: dp
      type(gt_history_varinfo),intent(inout) :: varinfo
      character(*), intent(in):: attrname ! 属性の名前
      real(DP), intent(in):: value(:)
      logical, intent(out), optional:: err
    end subroutine historyvarinfoaddattr2double1
 
 
  end interface
 
  interface historygetattr
 
 
    subroutine historygettattrchar0( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      character(*), intent(out):: value
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrchar0
 
 
    subroutine historygettattrint0( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      integer, intent(out):: value
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrint0
 
 
    subroutine historygettattrint1( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      integer, intent(out):: value(:)
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrint1
 
 
    subroutine historygettattrreal0( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      real, intent(out):: value
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrreal0
 
 
    subroutine historygettattrreal1( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      real, intent(out):: value(:)
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrreal1
 
 
    subroutine historygettattrdouble0( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      real(DP), intent(out):: value
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrdouble0
 
 
    subroutine historygettattrdouble1( &
      & file, varname, attrname, & ! (in)
      & value, &                   ! (out)
      & flag_mpi_split, &          ! (in) optional
      & err )                      ! (out) optional
 
      use dc_types, only: dp
      character(*), intent(in):: file
      character(*), intent(in):: varname
      character(*), intent(in):: attrname
      real(DP), intent(out):: value(:)
      logical, intent(in), optional:: flag_mpi_split
      logical, intent(out), optional:: err
 
    end subroutine historygettattrdouble1
 
 
  end interface
 
 
                        !--------------------------
  !  固定長配列用
  !  For fixed length array
  interface historyget
                      
 
 
    subroutine historygetdouble0( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0
 
 
    subroutine historygetdouble0timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0timed
 
 
    subroutine historygetdouble0timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0timer
 
 
    subroutine historygetdouble0timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0timei
 
 
    subroutine historygetdouble1( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1
 
 
    subroutine historygetdouble1timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1timed
 
 
    subroutine historygetdouble1timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1timer
 
 
    subroutine historygetdouble1timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1timei
 
 
    subroutine historygetdouble2( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2
 
 
    subroutine historygetdouble2timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2timed
 
 
    subroutine historygetdouble2timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2timer
 
 
    subroutine historygetdouble2timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2timei
 
 
    subroutine historygetdouble3( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3
 
 
    subroutine historygetdouble3timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3timed
 
 
    subroutine historygetdouble3timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3timer
 
 
    subroutine historygetdouble3timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3timei
 
 
    subroutine historygetdouble4( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4
 
 
    subroutine historygetdouble4timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4timed
 
 
    subroutine historygetdouble4timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4timer
 
 
    subroutine historygetdouble4timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4timei
 
 
    subroutine historygetdouble5( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5
 
 
    subroutine historygetdouble5timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5timed
 
 
    subroutine historygetdouble5timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5timer
 
 
    subroutine historygetdouble5timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5timei
 
 
    subroutine historygetdouble6( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6
 
 
    subroutine historygetdouble6timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6timed
 
 
    subroutine historygetdouble6timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6timer
 
 
    subroutine historygetdouble6timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6timei
 
 
    subroutine historygetdouble7( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7
 
 
    subroutine historygetdouble7timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7timed
 
 
    subroutine historygetdouble7timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7timer
 
 
    subroutine historygetdouble7timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7timei
 
 
    subroutine historygetreal0( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0
 
 
    subroutine historygetreal0timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0timed
 
 
    subroutine historygetreal0timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0timer
 
 
    subroutine historygetreal0timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0timei
 
 
    subroutine historygetreal1( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1
 
 
    subroutine historygetreal1timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1timed
 
 
    subroutine historygetreal1timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1timer
 
 
    subroutine historygetreal1timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1timei
 
 
    subroutine historygetreal2( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2
 
 
    subroutine historygetreal2timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2timed
 
 
    subroutine historygetreal2timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2timer
 
 
    subroutine historygetreal2timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2timei
 
 
    subroutine historygetreal3( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3
 
 
    subroutine historygetreal3timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3timed
 
 
    subroutine historygetreal3timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3timer
 
 
    subroutine historygetreal3timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3timei
 
 
    subroutine historygetreal4( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4
 
 
    subroutine historygetreal4timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4timed
 
 
    subroutine historygetreal4timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4timer
 
 
    subroutine historygetreal4timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4timei
 
 
    subroutine historygetreal5( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5
 
 
    subroutine historygetreal5timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5timed
 
 
    subroutine historygetreal5timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5timer
 
 
    subroutine historygetreal5timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5timei
 
 
    subroutine historygetreal6( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6
 
 
    subroutine historygetreal6timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6timed
 
 
    subroutine historygetreal6timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6timer
 
 
    subroutine historygetreal6timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6timei
 
 
    subroutine historygetreal7( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7
 
 
    subroutine historygetreal7timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7timed
 
 
    subroutine historygetreal7timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7timer
 
 
    subroutine historygetreal7timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7timei
 
 
    subroutine historygetint0( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0
 
 
    subroutine historygetint0timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0timed
 
 
    subroutine historygetint0timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0timer
 
 
    subroutine historygetint0timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0timei
 
 
    subroutine historygetint1( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1
 
 
    subroutine historygetint1timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1timed
 
 
    subroutine historygetint1timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1timer
 
 
    subroutine historygetint1timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1timei
 
 
    subroutine historygetint2( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2
 
 
    subroutine historygetint2timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2timed
 
 
    subroutine historygetint2timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2timer
 
 
    subroutine historygetint2timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2timei
 
 
    subroutine historygetint3( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3
 
 
    subroutine historygetint3timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3timed
 
 
    subroutine historygetint3timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3timer
 
 
    subroutine historygetint3timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3timei
 
 
    subroutine historygetint4( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4
 
 
    subroutine historygetint4timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4timed
 
 
    subroutine historygetint4timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4timer
 
 
    subroutine historygetint4timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4timei
 
 
    subroutine historygetint5( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5
 
 
    subroutine historygetint5timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5timed
 
 
    subroutine historygetint5timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5timer
 
 
    subroutine historygetint5timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5timei
 
 
    subroutine historygetint6( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6
 
 
    subroutine historygetint6timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6timed
 
 
    subroutine historygetint6timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6timer
 
 
    subroutine historygetint6timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6timei
 
 
    subroutine historygetint7( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7
 
 
    subroutine historygetint7timed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7timed
 
 
    subroutine historygetint7timer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7timer
 
 
    subroutine historygetint7timei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, intent(out):: array(:,:,:,:,:,:,:)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7timei
 
 
  end interface
 
 
                        !--------------------------
  !  ポインタ配列用
  !  For pointer array
  interface historygetpointer
                      
 
 
    subroutine historygetdouble0pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0pointer
 
 
    subroutine historygetdouble0pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0pointertimed
 
 
    subroutine historygetdouble0pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0pointertimer
 
 
    subroutine historygetdouble0pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble0pointertimei
 
 
    subroutine historygetdouble1pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1pointer
 
 
    subroutine historygetdouble1pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1pointertimed
 
 
    subroutine historygetdouble1pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1pointertimer
 
 
    subroutine historygetdouble1pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble1pointertimei
 
 
    subroutine historygetdouble2pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2pointer
 
 
    subroutine historygetdouble2pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2pointertimed
 
 
    subroutine historygetdouble2pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2pointertimer
 
 
    subroutine historygetdouble2pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble2pointertimei
 
 
    subroutine historygetdouble3pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3pointer
 
 
    subroutine historygetdouble3pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3pointertimed
 
 
    subroutine historygetdouble3pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3pointertimer
 
 
    subroutine historygetdouble3pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble3pointertimei
 
 
    subroutine historygetdouble4pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4pointer
 
 
    subroutine historygetdouble4pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4pointertimed
 
 
    subroutine historygetdouble4pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4pointertimer
 
 
    subroutine historygetdouble4pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble4pointertimei
 
 
    subroutine historygetdouble5pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5pointer
 
 
    subroutine historygetdouble5pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5pointertimed
 
 
    subroutine historygetdouble5pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5pointertimer
 
 
    subroutine historygetdouble5pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble5pointertimei
 
 
    subroutine historygetdouble6pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6pointer
 
 
    subroutine historygetdouble6pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6pointertimed
 
 
    subroutine historygetdouble6pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6pointertimer
 
 
    subroutine historygetdouble6pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble6pointertimei
 
 
    subroutine historygetdouble7pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7pointer
 
 
    subroutine historygetdouble7pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7pointertimed
 
 
    subroutine historygetdouble7pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7pointertimer
 
 
    subroutine historygetdouble7pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real(DP), pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetdouble7pointertimei
 
 
    subroutine historygetreal0pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0pointer
 
 
    subroutine historygetreal0pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0pointertimed
 
 
    subroutine historygetreal0pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0pointertimer
 
 
    subroutine historygetreal0pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal0pointertimei
 
 
    subroutine historygetreal1pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1pointer
 
 
    subroutine historygetreal1pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1pointertimed
 
 
    subroutine historygetreal1pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1pointertimer
 
 
    subroutine historygetreal1pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal1pointertimei
 
 
    subroutine historygetreal2pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2pointer
 
 
    subroutine historygetreal2pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2pointertimed
 
 
    subroutine historygetreal2pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2pointertimer
 
 
    subroutine historygetreal2pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal2pointertimei
 
 
    subroutine historygetreal3pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3pointer
 
 
    subroutine historygetreal3pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3pointertimed
 
 
    subroutine historygetreal3pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3pointertimer
 
 
    subroutine historygetreal3pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal3pointertimei
 
 
    subroutine historygetreal4pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4pointer
 
 
    subroutine historygetreal4pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4pointertimed
 
 
    subroutine historygetreal4pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4pointertimer
 
 
    subroutine historygetreal4pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal4pointertimei
 
 
    subroutine historygetreal5pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5pointer
 
 
    subroutine historygetreal5pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5pointertimed
 
 
    subroutine historygetreal5pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5pointertimer
 
 
    subroutine historygetreal5pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal5pointertimei
 
 
    subroutine historygetreal6pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6pointer
 
 
    subroutine historygetreal6pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6pointertimed
 
 
    subroutine historygetreal6pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6pointertimer
 
 
    subroutine historygetreal6pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal6pointertimei
 
 
    subroutine historygetreal7pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7pointer
 
 
    subroutine historygetreal7pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7pointertimed
 
 
    subroutine historygetreal7pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7pointertimer
 
 
    subroutine historygetreal7pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              real, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetreal7pointertimei
 
 
    subroutine historygetint0pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0pointer
 
 
    subroutine historygetint0pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0pointertimed
 
 
    subroutine historygetint0pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0pointertimer
 
 
    subroutine historygetint0pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint0pointertimei
 
 
    subroutine historygetint1pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1pointer
 
 
    subroutine historygetint1pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1pointertimed
 
 
    subroutine historygetint1pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1pointertimer
 
 
    subroutine historygetint1pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint1pointertimei
 
 
    subroutine historygetint2pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2pointer
 
 
    subroutine historygetint2pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2pointertimed
 
 
    subroutine historygetint2pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2pointertimer
 
 
    subroutine historygetint2pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint2pointertimei
 
 
    subroutine historygetint3pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3pointer
 
 
    subroutine historygetint3pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3pointertimed
 
 
    subroutine historygetint3pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3pointertimer
 
 
    subroutine historygetint3pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint3pointertimei
 
 
    subroutine historygetint4pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4pointer
 
 
    subroutine historygetint4pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4pointertimed
 
 
    subroutine historygetint4pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4pointertimer
 
 
    subroutine historygetint4pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint4pointertimei
 
 
    subroutine historygetint5pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5pointer
 
 
    subroutine historygetint5pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5pointertimed
 
 
    subroutine historygetint5pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5pointertimer
 
 
    subroutine historygetint5pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint5pointertimei
 
 
    subroutine historygetint6pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6pointer
 
 
    subroutine historygetint6pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6pointertimed
 
 
    subroutine historygetint6pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6pointertimer
 
 
    subroutine historygetint6pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint6pointertimei
 
 
    subroutine historygetint7pointer( &
      & file, varname, array, range, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      character(*), intent(in), optional:: range
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7pointer
 
 
    subroutine historygetint7pointertimed( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real(DP), intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7pointertimed
 
 
    subroutine historygetint7pointertimer( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      real, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7pointertimer
 
 
    subroutine historygetint7pointertimei( &
      & file, varname, array, time, quiet, &
      & flag_mpi_split, returned_time, flag_time_exist, err)
 
      use dc_types, only: dp
      character(*), intent(in):: file, varname
      integer, intent(in):: time
      logical, intent(in), optional:: quiet
                              integer, pointer:: array(:,:,:,:,:,:,:) ! (out)
                        
      logical, intent(in), optional:: flag_mpi_split
      real(DP), intent(out), optional:: returned_time
      logical, intent(out), optional:: flag_time_exist
      logical, intent(out), optional:: err
    end subroutine historygetint7pointertimei
 
 
  end interface
 
 
  character(*), parameter:: version = &
    & '$Name:  $' // &
    & '$Id: gtool_history_generic.rb2f90,v 1.9 2010-06-17 00:56:25 morikawa Exp $'
 
end module gtool_history_generic
 
!--
! vi:set readonly sw=4 ts=8:
!
!Local Variables:
!mode: f90
!buffer-read-only: t
!End:
!
!++