anchor.diff:              allocate(r_i(3, N))
               allocate(r_np_i(3, N))
               allocate(r_right(3, N))
  +            allocate(m_i(N))
  +            allocate(m_np_i(N))
  +            allocate(m_right(N))
   
               a_right = 0._xp
   
  
positive.code:                ! Note: use nprocs-i-1, because nprocs start at 0
                 np_i = nprocs - i - 1
  
                 if (rank == np_i) then
                    call mpi_send(r,       3*N, MPI_REAL_XP,    i, 0, MPI_COMM_WORLD, err)
                 else if (rank == i) then
                    call mpi_recv(r_right, 3*N, MPI_REAL_XP, np_i, 0, MPI_COMM_WORLD, stat, err)
                 end if
  
                 if (rank == i) then
                    r_i = r
                 else if (rank == np_i) then
                    r_np_i = r
                 end if
  
                 ! Broadcast i-th data
                 call mpi_bcast(r_i,    3*N, MPI_REAL_XP,    i, MPI_COMM_WORLD, err)
  
                 ! Broadcast n-i-th data
                 call mpi_bcast(r_np_i, 3*N, MPI_REAL_XP, np_i, MPI_COMM_WORLD, err)
  
                 ! compute own interactions
                 a_comm_i = 0._xp
                 a_comm_np_i = 0._xp
                 if (rank == i) then
                    a_right = 0._xp
                    call compute_force_diag(m, r,       1, N/2, N, a)
                    call compute_force_diag(m, r_right, 1, N/2, N, a_right)
                    a_comm_i = a
  
                    ! compute interaction on right side
                 else if (rank < i) then
                    call compute_force_mpi(m, r_np_i, 1, N, r_right, 1, N, a_comm_np_i, a_right)
  
                    ! compute interaction on left side
                 else
                    call compute_force_mpi(m, r_i,    1, N, r,       1, N, a_comm_i, a)
  
                    if (rank == np_i) then
                       a_comm_np_i = a
  
negative.code: 
        real(xp), allocatable :: a_comm_i(:, :), a_comm_np_i(:, :), a_right(:, :)
        real(xp), allocatable :: r_i(:, :), r_np_i(:, :), r_right(:, :)
        real(xp), allocatable :: m_i(:), m_np_i(:), m_right(:)
        real(xp), allocatable :: a_reduced(:, :)
  
        integer :: err = 0
  