anchor.diff:                 if (debug) call mpi_barrier(MPI_COMM_WORLD, err)
   
                  ! compute own interactions
  -               a_comm = 0._xp
  +               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, N, a)
                     call compute_force_diag(m, r_right, 1, N, N, a_right)
  -                  a_comm = a
  +                  a_comm_i = a
   
                     ! compute interaction on right side
                  else if (rank < i) then
  -                  call compute_force(m, r_right, 1, N, r_np_i, 1, N, a_right)
  +                  call compute_force(m, r_np_i, 1, N, r_right, 1, N, a_comm_np_i)
  +                  a_right = a_right - a_comm_np_i
  +
                     ! compute interaction on left side
                  else
  -                  call compute_force(m, r_i, 1, N, r, 1, N, a_comm)
  -                  a = a - a_comm ! FIXME: False with different masses
  +                  call compute_force(m, r_i, 1, N, r, 1, N, a_comm_i)
  +                  a = a - a_comm_i ! FIXME: False with different masses
  +
  +                  if (rank == nprocs - i - 1) then
  +                     a_comm_np_i = a
  +                  end if
  +
                  end if
   
                  if (rank == i) then
  
positive.code: 
        real(xp), intent(out) :: a(:,:)
  
        real(xp), allocatable :: a_comm(:, :), a_right(:, :)
        real(xp), allocatable :: r_i(:, :), r_np_i(:, :), r_right(:, :)
        real(xp), allocatable :: a_reduced(:, :)
  
  
negative.code:                print*, 'Exchanged'
                 print*, ''
              end if
              deallocate(a_comm_i)
              deallocate(a_comm_np_i)
              deallocate(a_right)
              deallocate(r_i)
              deallocate(r_np_i)
  