gtool_history_generic.f90

Go to the documentation of this file.

!--
! *** Caution!! ***
!
! This file is generated from "gtool_history_generic.rb2f90" by Ruby 2.3.3.
! Please do not edit this file directly.
!
! [JAPANESE]
!
! ※※※ 注意!!! ※※※
!
! このファイルは "gtool_history_generic.rb2f90" から Ruby 2.3.3
! によって自動生成されたファイルです.
! このファイルを直接編集しませんようお願い致します.
!
!
!++
!
!= gtool_history より提供される手続の引用仕様宣言
!= Interfaces of procedures provided from "gtool_history"
!
! Authors::   Yasuhiro MORIKAWA, Eizi TOYODA
! Version::   $Id: gtool_history_generic.rb2f90,v 1.9 2010-06-17 00:56:25 morikawa Exp $
! Tag Name::  $Name:  $
! Copyright:: Copyright (C) GFD Dennou Club, 2000-2009. All rights reserved.
! License::   See COPYRIGHT[link:../../../COPYRIGHT]
!

module gtool_history_generic
  !
  != gtool_history より提供される手続の引用仕様宣言
  != Interfaces of procedures provided from "gtool_history"
  !
  ! <b>Note that Japanese and English are described in parallel.</b>
  !
  ! モジュールの概要や使用方法については, gtool_history
  ! を参照ください.
  !
  ! See "gtool_history" for brief and usage of this module.
  !
  !== Procedures List
  !
  ! 【出力用】
  !
  ! 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 :: 初期設定チェック
  !

  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:
!
!++