anchor.diff:      endif
   
       call hecmw_mpc_mat_finalize(hecMESH, hecMAT, hecMATmpc)
  -
  -    call cpu_time(time_2)
  -    if( hecMESH%my_rank == 0 ) then
  -      write(ISTA,'(a,f10.2)') '         solve (sec) :', time_2 - time_1
  -    end if
   
     end subroutine fstr_solve_dynamic_nlexplicit
   
  
positive.code:       !C-- contact corrector
        !C
        do j = 1 ,ndof*nnod
          fstrSOLID%unode(j)  = fstrDYNAMIC%DISP(j,1)
          fstrSOLID%dunode(j)  = hecMAT%X(j)-fstrDYNAMIC%DISP(j,1)
        enddo
        if( associated( fstrSOLID%contacts ) )  then
          !call fstr_scan_contact_state( 1, fstrDYNAMIC%t_delta, kcaSLAGRANGE, hecMESH, fstrSOLID, infoCTChange )
          call forward_increment_Lagrange(1,ndof,fstrDYNAMIC%VEC1,hecMESH,fstrSOLID,infoCTChange,&
            & fstrDYNAMIC%DISP(:,2),fstrSOLID%ddunode)
          do j = 1 ,ndof*nnod
            hecMAT%X(j)  = hecMAT%X(j) + fstrSOLID%ddunode(j)
          enddo
        endif
  
        !C
        !C-- new displacement, velocity and accelaration
        !C
        do j = 1 ,ndof*nnod
          fstrDYNAMIC%ACC (j,1) = a1*(hecMAT%X(j) - 2.d0*fstrDYNAMIC%DISP(j,1) &
            + fstrDYNAMIC%DISP(j,3))
          fstrDYNAMIC%VEL (j,1) = a2*(hecMAT%X(j) - fstrDYNAMIC%DISP(j,3))
  
          fstrSOLID%unode(j)  = fstrDYNAMIC%DISP(j,1)
          fstrSOLID%dunode(j)  = hecMAT%X(j)-fstrDYNAMIC%DISP(j,1)
  
          fstrDYNAMIC%DISP(j,3) = fstrDYNAMIC%DISP(j,1)
          fstrDYNAMIC%DISP(j,1) = hecMAT%X(j)
  
          hecMAT%X(j)  = fstrSOLID%dunode(j)
        end do
  
        ! ----- update strain, stress, and internal force
        call fstr_UpdateNewton( hecMESH, hecMAT, fstrSOLID, fstrDYNAMIC%t_curr, fstrDYNAMIC%t_delta, 1 )
  
        do j = 1 ,ndof*nnod
          fstrSOLID%unode(j)  = fstrSOLID%unode(j) + fstrSOLID%dunode(j)
        end do
        call fstr_UpdateState( hecMESH, fstrSOLID, fstrDYNAMIC%t_delta )
  
        if( fstrDYNAMIC%restart_nout > 0 .and. &
            (mod(i,fstrDYNAMIC%restart_nout).eq.0 .or. i.eq.fstrDYNAMIC%n_step) ) then
          call fstr_write_restart_dyna_nl(i,hecMESH,fstrSOLID,fstrDYNAMIC,fstrPARAM)
        end if
        !
        !C-- output new displacement, velocity and accelaration
        call fstr_dynamic_Output(hecMESH, fstrSOLID, fstrDYNAMIC, fstrPARAM)
        call dynamic_output_monit(hecMESH, fstrPARAM, fstrDYNAMIC, fstrEIG, fstrSOLID)
  
      enddo
  
  
negative.code:   !C-- subroutine  fstr_solve_LINEAR_DYNAMIC
    !C================================================================C
    subroutine fstr_solve_dynamic_nlexplicit(hecMESH,hecMAT,fstrSOLID,fstrEIG   &
        ,fstrDYN,fstrRESULT,fstrPARAM,infoCTChange &
        ,fstrCPL, restrt_step_num )
      implicit none
      type(hecmwST_local_mesh)             :: hecMESH
      type(hecmwST_matrix)                 :: hecMAT
      type(fstr_eigen)                     :: fstrEIG
      type(fstr_solid)                     :: fstrSOLID
      type(hecmwST_result_data)            :: fstrRESULT
      type(fstr_param)                     :: fstrPARAM
      type(fstr_dynamic)                   :: fstrDYN
      type(fstrST_matrix_contact_lagrange) :: fstrMAT !< type fstrST_matrix_contact_lagrange
      type(fstr_info_contactChange)        :: infoCTChange !< fstr_info_contactChange
      type(fstr_couple)                    :: fstrCPL !for COUPLE
      type(hecmwST_matrix), pointer :: hecMATmpc
      integer(kind=kint), allocatable :: mark(:)
      integer(kind=kint) :: nnod, ndof, nn, numnp
  