anchor.diff:                 if (rank == i) then
                     if (debug) print*, 'R:', i, '(2/2) sends to:', nprocs-i-1
                     call mpi_send(a_right, 3*N, MPI_REAL_XP, nprocs-i-1, 0, MPI_COMM_WORLD, err)
  +                  
                  else if (rank == nprocs-i-1) then
                     if (debug) print*, 'R:', rank, '(2/2) gets from:', i
  -                  call mpi_recv(a_comm, 3*N, MPI_REAL_XP, i, 0, MPI_COMM_WORLD, stat, err)
  -                  a = a + a_comm
  +                  call mpi_recv(a_comm_i, 3*N, MPI_REAL_XP, i, 0, MPI_COMM_WORLD, stat, err)
  +                  a = a + a_comm_i
                  end if
                  if (debug) call mpi_barrier(MPI_COMM_WORLD, err)
               end do
  
positive.code:                if (debug) call mpi_barrier(MPI_COMM_WORLD, err)
  
                 ! compute own interactions
                 a_comm = 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
  
                    ! 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)
                    ! 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
                 end if
  
                 if (rank == i) then
  
negative.code:             !--------------------------------
              ! Allocate and initialize
              !--------------------------------
              allocate(a_comm_i(3, N))
              allocate(a_comm_np_i(3, N))
              allocate(a_right(3, N))
              allocate(r_i(3, N))
              allocate(r_np_i(3, N))
  