anchor.diff:      allocate(this(n(1),n(2),n(3)), stat=istat); call mErr(istat,'allocate_l3D:this',1)
     end subroutine
     !====================================================================!
  +  !====================================================================!
  +  module subroutine allocate_lb_l1D(this, lb, n)
  +    !! Interfaced with [[allocate]]
  +  !====================================================================!
  +    logical, allocatable, intent(inout) :: this(:) !! 1D array
  +    integer(i32), intent(in) :: lb !! Lower index, default = 1.
  +    integer(i32), intent(in) :: n !! Allocation size
  +
  +    integer(i32) :: istat
  +
  +    if(allocated(this)) then
  +      if (n == size(this)) then
  +        if (lbound(this, 1) == lb) then
  +          return ! Don't need to allocate the same size
  +        end if
  +      end if
  +      deallocate(this) ! No need to duplicate memory
  +    end if
  +
  +    allocate(this(lb:lb+n-1), stat=istat); call mErr(istat,'allocate_l1D:this',1)
  +  end subroutine
  +  !====================================================================!
  +  !====================================================================!
  +  module subroutine allocate_lb_l2D(this, lb, n)
  +    !! Interfaced with [[allocate]]
  +  !====================================================================!
  +    logical, allocatable, intent(inout) :: this(:,:) !! 1D array
  +    integer(i32), intent(in) :: lb(2) !! Lower index, default = 1.
  +    integer(i32), intent(in) :: n(2) !! Allocation size
  +
  +    integer(i32) :: istat
  +
  +    if(allocated(this)) then
  +      if (all(n == shape(this))) then
  +        if (all(lbound(this) == lb)) then
  +          return ! Don't need to allocate the same size
  +        end if
  +      end if
  +      deallocate(this) ! No need to duplicate memory
  +    end if
  +    allocate(this(lb(1):lb(1)+n(1)-1, lb(2):lb(2)+n(2)-1), stat=istat); call mErr(istat,'allocate_l2D:this',1)
  +  end subroutine
  +  !====================================================================!
  +  !====================================================================!
  +  module subroutine allocate_lb_l3D(this, lb, n)
  +    !! Interfaced with [[allocate]]
  +  !====================================================================!
  +    logical, allocatable, intent(inout) :: this(:,:,:) !! 1D array
  +    integer(i32), intent(in) :: lb(3) !! Lower index, default = 1.
  +    integer(i32), intent(in) :: n(3) !! Allocation size
  +
  +    integer(i32) :: istat
  +
  +    if(allocated(this)) then
  +      if (all(n == shape(this))) then
  +        if (all(lbound(this) == lb)) then
  +          return ! Don't need to allocate the same size
  +        end if
  +      end if
  +      deallocate(this) ! No need to duplicate memory
  +    end if
  +    allocate(this(lb(1):lb(1)+n(1)-1, lb(2):lb(2)+n(2)-1, lb(3):lb(3)+n(3)-1), stat=istat); call mErr(istat,'allocate_l3D:this',1)
  +  end subroutine
  +  !====================================================================!
  +
     !====================================================================!
     subroutine allocate_test(test)
       !! graph: false
  
positive.code:       !!Interfaced with  [[allocate]]
        logical, allocatable, intent(inout) :: this(:,:,:) !! 3D array
        integer(i32), intent(in) :: n(3) !! Allocation size
      end subroutine
      !====================================================================!
    end interface
  
negative.code:   call test%test(all(shape(ar2D) == [5,6]),'allocate_r2D')
    call allocate(ar3D, [10,9,8])
    call test%test(all(shape(ar3D) == [10,9,8]),'allocate_r3D')
    call allocate(ar1D, -10, 100)
    call test%test(lbound(ar1D,1) == -10 .and. size(ar1D) == 100, 'allocate_lb_r1D')
    call allocate(ar2D, [-3, -2], [5,6])
    call test%test(all(lbound(ar2D) == [-3, -2]) .and. all(shape(ar2D) == [5,6]),'allocate_lb_r2D')
    call allocate(ar3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(ar3D) == [-3, -5, -7]) .and. all(shape(ar3D) == [10,9,8]),'allocate_lb_r3D')
  
    call allocate(a1D, 100)
    call test%test(size(a1D) == 100,'allocate_d1D')
    call allocate(a2D, [5,6])
    call test%test(all(shape(a2D) == [5,6]),'allocate_d2D')
    call allocate(a3D, [10,9,8])
    call test%test(all(shape(a3D) == [10,9,8]),'allocate_d3D')
    call allocate(a1D, -10, 100)
    call test%test(lbound(a1D,1) == -10 .and. size(a1D) == 100, 'allocate_lb_d1D')
    call allocate(a2D, [-3, -2], [5,6])
    call test%test(all(lbound(a2D) == [-3, -2]) .and. all(shape(a2D) == [5,6]),'allocate_lb_d2D')
    call allocate(a3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(a3D) == [-3, -5, -7]) .and. all(shape(a3D) == [10,9,8]),'allocate_lb_d3D')
  
    call allocate(ia1D, 100)
    call test%test(size(ia1D) == 100,'allocate_i1D')
    call allocate(ia2D, [5,6])
    call test%test(all(shape(ia2D) == [5,6]),'allocate_i2D')
    call allocate(ia3D, [10,9,8])
    call test%test(all(shape(ia3D) == [10,9,8]),'allocate_i3D')
    call allocate(ia1D, -10, 100)
    call test%test(lbound(ia1D,1) == -10 .and. size(ia1D) == 100, 'allocate_lb_i1D')
    call allocate(ia2D, [-3, -2], [5,6])
    call test%test(all(lbound(ia2D) == [-3, -2]) .and. all(shape(ia2D) == [5,6]),'allocate_lb_i2D')
    call allocate(ia3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(ia3D) == [-3, -5, -7]) .and. all(shape(ia3D) == [10,9,8]),'allocate_lb_i3D')
  
    call allocate(iad1D, 100)
    call test%test(size(iad1D) == 100,'allocate_id1D')
    call allocate(iad2D, [5,6])
    call test%test(all(shape(iad2D) == [5,6]),'allocate_id2D')
    call allocate(iad3D, [10,9,8])
    call test%test(all(shape(iad3D) == [10,9,8]),'allocate_id3D')
    call allocate(iad1D, -10, 100)
    call test%test(lbound(iad1D,1) == -10 .and. size(iad1D) == 100, 'allocate_lb_id1D')
    call allocate(iad2D, [-3, -2], [5,6])
    call test%test(all(lbound(iad2D) == [-3, -2]) .and. all(shape(iad2D) == [5,6]),'allocate_lb_id2D')
    call allocate(iad3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(iad3D) == [-3, -5, -7]) .and. all(shape(iad3D) == [10,9,8]),'allocate_lb_id3D')
  
    call allocate(z1D, 100)
    call test%test(size(z1D) == 100,'allocate_c1D')
    call allocate(z2D, [5,6])
    call test%test(all(shape(z2D) == [5,6]),'allocate_c2D')
    call allocate(z3D, [10,9,8])
    call test%test(all(shape(z3D) == [10,9,8]),'allocate_c3D')
    call allocate(z1D, -10, 100)
    call test%test(lbound(z1D,1) == -10 .and. size(z1D) == 100, 'allocate_lb_c1D')
    call allocate(z2D, [-3, -2], [5,6])
    call test%test(all(lbound(z2D) == [-3, -2]) .and. all(shape(z2D) == [5,6]),'allocate_lb_c2D')
    call allocate(z3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(z3D) == [-3, -5, -7]) .and. all(shape(z3D) == [10,9,8]),'allocate_lb_c3D')
  
    call allocate(zz1D, 100)
    call test%test(size(zz1D) == 100,'allocate_z1D')
    call allocate(zz2D, [5,6])
    call test%test(all(shape(zz2D) == [5,6]),'allocate_z2D')
    call allocate(zz3D, [10,9,8])
    call test%test(all(shape(zz3D) == [10,9,8]),'allocate_z3D')
    call allocate(zz1D, -10, 100)
    call test%test(lbound(zz1D,1) == -10 .and. size(zz1D) == 100, 'allocate_lb_z1D')
    call allocate(zz2D, [-3, -2], [5,6])
    call test%test(all(lbound(zz2D) == [-3, -2]) .and. all(shape(zz2D) == [5,6]),'allocate_lb_z2D')
    call allocate(zz3D, [-3, -5, -7], [10,9,8])
    call test%test(all(lbound(zz3D) == [-3, -5, -7]) .and. all(shape(zz3D) == [10,9,8]),'allocate_lb_z3D')
  
    call allocate(la1D, 100)
    call test%test(size(la1D) == 100,'allocate_l1D')
    call allocate(la2D, [5,6])
  