#!/usr/bin/env ruby

require 'scanf'

class Array
  def find_all_indices(elt)
    return self.each_index.select { |i| self[i] == elt }
  end
end

class Vector
  attr_accessor :x, :y, :z

  def initialize(array)
    @x = array[0] || 0
    @y = array[1] || 0
    @z = array[2] || 0
  end

  def add!(vector)
    @x += vector.x
    @y += vector.y
    @z += vector.z
  end

  def to_s
    return "<#{@x},#{@y},#{@z}>"
  end
end

class Particle
  attr_accessor :pos, :vel, :acc

  def initialize(p, v, a)
    @pos = Vector.new(p)
    @vel = Vector.new(v)
    @acc = Vector.new(a)
    @destroyed = false
  end

  def destroy!
    @destroyed = true
  end

  def destroyed?
    return @destroyed
  end

  def collides?(other)
    return @pos.x == other.pos.x &&
           @pos.y == other.pos.y &&
           @pos.z == other.pos.z
  end

  def update!
    @vel.add!(@acc)
    @pos.add!(@vel)
  end

  def to_s
    return "p=#{@pos}, v=#{@vel}, a=#{@acc}"
  end
end

input = $stdin.readlines.map(&:chomp)

particles = input.map do |line|
  px, py, pz, vx, vy, vz, ax, ay, az = 
    line.scanf("p=<%d,%d,%d>, v=<%d,%d,%d>, a=<%d,%d,%d>")
  Particle.new([px, py, pz], [vx, vy, vz], [ax, ay, az])
end

times = 0

THE_LONG_RUN = 1000

loop do
  collision = false

  (0...particles.length).each do |i|
    (i+1...particles.length).each do |j|
      if particles[i].collides?(particles[j]) then
        collision = true
        particles[i].destroy!
        particles[j].destroy!
      end
    end
  end

  if !collision then
    times += 1
  else
    times = 0
  end

  break if times == THE_LONG_RUN

  particles.each(&:update!)
  particles = particles.reject(&:destroyed?)
end

p particles.length