Simulation is an important application area in computer science involving the development of computer models to provide insight into real-world events. There are many kinds of simulation including (and certainly not limited to) discrete event simulation and clock-driven simulation. Simulation often involves approximating observed behavior in order to develop a practical approach.

This problem involves the simulation of a simplistic *pinball*
machine. In a pinball machine, a steel ball rolls around a surface, hitting
various objects (*bumpers*) and accruing points until the ball
``disappears'' from the surface.

You are to write a program that simulates an idealized pinball machine. This
machine has a flat surface that has some obstacles (bumpers and walls). The
surface is modeled as an grid with the origin in
the lower-left corner. Each bumper occupies a grid point. The grid positions on
the edge of the surface are walls. Balls are shot (appear) one at a time on the
grid, with an initial position, direction, and lifetime. In this simulation, all
positions are integral, and the ball's direction is one of: up, down, left, or
right. The ball bounces around the grid, hitting bumpers (which accumulates
points) and walls (which does not add any points). The number of points
accumulated by hitting a given bumper is the *value* of that bumper. The
speed of all balls is one grid space per timestep. A ball ``hits'' an obstacle
during a timestep when it would otherwise move on top of the bumper or wall grid
point. A hit causes the ball to ``rebound'' by turning right (clockwise) 90
degrees, without ever moving on top of the obstacle and without changing
position (only the direction changes as a result of a rebound). Note that by
this definition sliding along a wall does not constitute ``hitting'' that wall.

A ball's lifetime indicates how many time units the ball will live before
disappearing from the surface. The ball uses one unit of lifetime for each grid
step it moves. It also uses some units of lifetime for each bumper or wall that
it hits. The lifetime used by a hit is the *cost* of that bumper or wall.
As long as the ball has a positive lifetime when it hits a bumper, it obtains
the full score for that bumper. Note that a ball with lifetime one will ``die''
during its next move and thus cannot obtain points for hitting a bumper during
this last move. Once the lifetime is non-positive (less than or equal to zero),
the ball disappears and the game continues with the next ball.

Your program should simulate one game of pinball. There are several input
lines that describe the game. The first line gives integers *m* and
*n*, separated by a space. This describes a cartesian grid where and on which the game is ``played''. It will be the case that 2 <
*m* < 51 and 2 < *n* < 51. The next line gives the integer
cost for hitting a wall. The next line gives the number of bumpers, an integer
. The next *p* lines
give the *x* position, *y* position, value, and cost, of each bumper,
as four integers per line separated by space(s). The *x* and *y*
positions of all bumpers will be in the range of the grid. The value and cost
may be any integer (i.e., they may be negative; a negative cost *adds*
lifetime to a ball that hits the bumper). The remaining lines of the file
represent the balls. Each line represents one ball, and contains four integers
separated by space(s): the initial *x* and *y* position of the ball,
the direction of movement, and its lifetime. The position will be in range (and
not on top of any bumper or wall). The direction will be one of four values: 0
for increasing *x* (right), 1 for increasing *y* (up), 2 for
decreasing *x* (left), and 3 for decreasing *y* (down). The lifetime
will be some positive integer.

There should be one line of output for each ball giving an integer number of points accumulated by that ball in the same order as the balls appear in the input. After all of these lines, the total points for all balls should be printed.

4 4 0 2 2 2 1 0 3 3 1 0 2 3 1 1 2 3 1 2 2 3 1 3 2 3 1 4 2 3 1 5

0 0 1 2 2 5