Problem:
Problem B: e-Market

The city of Hakodate recently established a commodity exchange market. To participate in the market, each dealer transmits through the Internet an order consisting of his or her name, the type of the order (buy or sell), the name of the commodity, and the quoted price.

In this market a deal can be made only if the price of a sell order is lower than or equal to the price of a buy order. The price of the deal is the mean of the prices of the buy and sell orders, where the mean price is rounded downward to the nearest integer. To exclude dishonest deals, no deal is made between a pair of sell and buy orders from the same dealer. The system of the market maintains the list of orders for which a deal has not been made and processes a new order in the following manner.

For a new sell order, a deal is made with the buy order with the highest price in the list satisfying the conditions. If there is more than one buy order with the same price, the deal is made with the earliest of them.

For a new buy order, a deal is made with the sell order with the lowest price in the list satisfying the conditions. If there is more than one sell order with the same price, the deal is made with the earliest of them.

The market opens at 7:00 and closes at 22:00 everyday. When the market closes, all the remaining orders are cancelled. To keep complete record of the market, the system of the market saves all the orders it received everyday.

The manager of the market asked the system administrator to make a program which reports the activity of the market. The report must contain two kinds of information. For each commodity the report must contain informationon the lowest, the average and the highest prices of successful deals. For each dealer, the report must contain information on the amounts the dealer paid and received for commodities.

Input

The input contains several data sets. Each data set represents the record of the market on one day. The first line of each data set contains an integer n (n < 1000) which is the number of orders in the record. Each line of the record describes an order, consisting of the name of the dealer, the type of the order, the name of the commodity, and the quoted price. They are separated by a single space character.

The name of a dealer consists of capital alphabetical letters and is less than 10 characters in length. The type of an order is indicated by a string, "BUY" or "SELL". The name of a commodity is a single capital letter. The quoted price is a positive integer less than 1000.

The orders in a record are arranged according to time when they were received and the first line of the record corresponds to the oldest order.

The end of the input is indicated by a line containing a zero.

Output

The output for each data set consists of two parts separated by a line containing two hyphen (`-') characters.

The first part is output for commodities. For each commodity, your program should output the name of the commodity and the lowest, the average and the highest prices of successful deals in one line. The name and the prices in a line should be separated by a space character. The average price is rounded downward to the nearest integer. The output should contain only the commodities for which deals are made and the order of the output must be alphabetic.

The second part is output for dealers. For each dealer, your program should output the name of the dealer, the amounts the dealer paid and received for commodities. The name and the numbers in a line should be separated by a space character. The output should contain all the dealers who transmitted orders. The order of dealers in the output must be lexicographic on their names. The lexicographic order is the order in which words in dictionaries are arranged.

The output for each data set should be followed by a linecontaining ten hyphen (`-') characters.

Sample Input

3
PERLIS SELL A 300
WILKES BUY A 200
HAMMING SELL A 100
4
BACKUS SELL A 10
FLOYD BUY A 20
IVERSON SELL B 30
BACKUS BUY B 40
7
WILKINSON SELL A 500
MCCARTHY BUY C 300
WILKINSON SELL C 200
DIJKSTRA SELL B 100
BACHMAN BUY A 400
DIJKSTRA BUY A 600
WILKINSON SELL A 300
2
ABCD SELL X 10
ABC BUY X 15
2
A SELL M 100
A BUY M 100
0

Output for the Sample Input

A 150 150 150
--
HAMMING 0 150
PERLIS 0 0
WILKES 150 0
----------
A 15 15 15
B 35 35 35
--
BACKUS 35 15
FLOYD 15 0
IVERSON 0 35
----------
A 350 450 550
C 250 250 250
--
BACHMAN 350 0
DIJKSTRA 550 0
MCCARTHY 250 0
WILKINSON 0 1150
----------
X 12 12 12
--
ABC 12 0
ABCD 0 12
----------
--
A 0 0
----------

Solution in Ruby (judge verdict: Accepted)

### constant

INF = 1 << 30

### main

loop do
  n = gets.to_i
  break if n == 0

  cmds = {}
  dlrs = {}
  ordrs = []

  n.times do
    dlr, type, cmd, pr = gets.strip.split
    pr = pr.to_i
    #p ["new order", dlr, type, cmd, pr]
    
    dlrs[dlr] = [0, 0] if dlrs[dlr].nil?
    
    case type
    when 'SELL'
      max_pr = 0
      max_i = nil

      for i in (0...ordrs.length)
        dlr0, type0, cmd0, pr0 = ordrs[i]
        if dlr0 != dlr && type0 != type && cmd0 == cmd && pr0 >= pr &&
           max_pr < pr0
          max_pr = pr0
          max_i = i
        end        
      end
      
      if ! max_i.nil?
        mpr = ((pr + max_pr) * 0.5).floor
        #p [max_i] + ordrs[max_i] + [mpr]
        cmds[cmd] = [0, INF, 0, 0] if cmds[cmd].nil?
        cmds[cmd][0] += 1
        cmds[cmd][1] = mpr if cmds[cmd][1] > mpr
        cmds[cmd][2] += mpr
        cmds[cmd][3] = mpr if cmds[cmd][3] < mpr

        dlrs[dlr][1] += mpr
        dlrs[ordrs[max_i][0]][0] += mpr

        ordrs.delete_at(max_i)
      else
        ordrs << [dlr, type, cmd, pr]
      end

    when 'BUY'
      min_pr = INF
      min_i = nil

      for i in (0...ordrs.length)
        dlr0, type0, cmd0, pr0 = ordrs[i]
        if dlr0 != dlr && type0 != type && cmd0 == cmd && pr0 <= pr &&
           min_pr > pr0
          min_pr = pr0
          min_i = i
        end        
      end
      
      if ! min_i.nil?
        mpr = ((pr + min_pr) * 0.5).floor
        #p [min_i] + ordrs[min_i] + [mpr]
        cmds[cmd] = [0, INF, 0, 0] if cmds[cmd].nil?
        cmds[cmd][0] += 1
        cmds[cmd][1] = mpr if cmds[cmd][1] > mpr
        cmds[cmd][2] += mpr
        cmds[cmd][3] = mpr if cmds[cmd][3] < mpr

        dlrs[dlr][0] += mpr
        dlrs[ordrs[min_i][0]][1] += mpr

        ordrs.delete_at(min_i)
      else
        ordrs << [dlr, type, cmd, pr]
      end
    end
  end
  #p cmds
  #p dlrs

  for cmd in cmds.keys.sort
    num, min, sum, max = cmds[cmd]
    ave = (sum.to_f / num).to_i
    puts [cmd, min, ave, max].join(' ')
  end
  puts '-' * 2

  for dlr in dlrs.keys.sort
    puts ([dlr] + dlrs[dlr]).join(' ')
  end
  puts '-' * 10
end