// Define class for mainline program

import java.io.*;
import java.util.*;

public class assignment1 {

    static public void main(String args[]) {
		try {
			BufferedReader in = new BufferedReader( new FileReader( args[0] ) );
			String st = in.readLine();
			boolean firstLine = true;
			while (st != null) {
				if (!firstLine) {
					parseAndOutput(st); // skip first line
				} else {
					firstLine = false;
				}
				st = in.readLine();
			}
		} catch (FileNotFoundException fnfe) {
			System.err.println(fnfe);
			System.err.println("Aborting");
		} catch (IOException ioe) {
			System.err.println(ioe);
			System.err.println("Aborting");
		}
    }

	private static void parseAndOutput(String s) {
		// Put all tokens into a ArrayList for easier traversal
		StringTokenizer st = new StringTokenizer(s);
		ArrayList v = new ArrayList();
		while (st.hasMoreTokens()) {
			v.add(st.nextToken());
		}
		
		if (v.size() >= 3) { // all valid elements have at least 3 items
			String s1 = (String)v.get(0);
			// pull apart known stuff
			char c = s1.charAt(0); // guaranteed to exist
			if (s1.length() == 1) return; // no name!
			String nodeName = s1.substring(1);
			String node1 = (String)v.get(1);
			String node2 = (String)v.get(2);
			v.remove(0); // elements not needed anymore
			v.remove(0);
			v.remove(0);
			// dispatch on first letter
			switch (c) {
				case 'C': capacitor(nodeName, node1, node2, v); break;
				case 'I': currentSource(nodeName, node1, node2, v); break;
				case 'L': inductor(nodeName, node1, node2, v); break;
				case 'R': resistor(nodeName, node1, node2, v); break;
				case 'V': voltageSource(nodeName, node1, node2, v); break;
				default: break;  // simply skip it
			}
		}
	}
	
	/**
	 * Output the necessary item for a resistor.  A valid resistor
	 * has one extra argument, its value.  Ignore all others.
	 * @param nName node name
	 * @param n1 name of from node
	 * @param n2 name of to node
	 * @param v extra argument(s)
	 */
	private static void resistor(String nName, String n1, String n2, ArrayList v) {
		// for valid resistors, output
		if (v.size() == 1) { 
			print5("Resistor ", nName, n1, n2, (String)v.get(0));
		}
	}
	
	/**
	 * Output the necessary item for a capacitor.  A valid capacitor
	 * has one extra argument, its value.  Ignore all others.
	 * @param nName node name
	 * @param n1 name of from node
	 * @param n2 name of to node
	 * @param v extra argument(s)
	 */
	private static void capacitor(String nName, String n1, String n2, ArrayList v) {
		// for valid capacitors, output
		if (v.size() == 1) { // is known to be >= 3 already.
			print5("Capacitor ", nName, n1, n2, (String)v.get(0));
		}
	}
	
	/**
	 * Output the necessary item for an inductor.  A valid inductor
	 * has one extra argument, its value.  Ignore all others.
	 * @param nName node name
	 * @param n1 name of from node
	 * @param n2 name of to node
	 * @param v extra argument(s)
	 */
	private static void inductor(String nName, String n1, String n2, ArrayList v) {
		// for valid inductors, output
		if (v.size() == 1) { // is known to be >= 3 already.
			print5("Inductor ", nName, n1, n2, (String)v.get(0));
		}
	}
	
	private static void print5(String a1, String a2, String a3, String a4, String a5) {
		System.out.println(a1+a2+" between nodes "+a3+" and "+a4
				+" has value "+a5);
	}

	/**
	 * Output the necessary item for a voltage source.  A valid voltage source
	 * has many possible extra arguments.  See parseExtras for details.
	 * @param nName node name
	 * @param n1 name of from node
	 * @param n2 name of to node
	 * @param v extra argument(s)
	 */
	private static void voltageSource(String nName, String n1, String n2, ArrayList v) {
		// for valid voltage sources, output
		if (v.size() == 0) { // no extra arguments (valid)
			System.out.println("Voltage source "+nName+" between nodes "+n1+" and "
					+n2);
		} else if (v.size() <= 4) { // up to 5 valid extra arguments
			String ending = parseExtras(v);
			if (ending != null) {
				System.out.println("Voltage source "+nName+" between nodes "+n1+" and "
					+n2+ending);
			}
		}
	}
	
	/**
	 * Output the necessary item for a current source.  A valid current source
	 * has many possible extra arguments.  See parseExtras for details.
	 * @param nName node name
	 * @param n1 name of from node
	 * @param n2 name of to node
	 * @param v extra argument(s)
	 */
	private static void currentSource(String nName, String n1, String n2, ArrayList v) {
		// for valid current sources, output
		if (v.size() == 0) { // no extra arguments (valid)
			System.out.println("Current source "+nName+" between nodes "+n1+" and "
					+n2);
		} else if (v.size() <= 4) { // up to 5 valid extra arguments
			String ending = parseExtras(v);
			if (ending != null) {
				System.out.println("Current source "+nName+" between nodes "+n1+" and "
					+n2+ending);
			}
		}
	}

	/** v contains at least 1 entry, maybe more
	 * return null if not a valid entry, else return the "ending" string
	 * Parses <<DC> DC/TRAN> <AC <ACMAG <ACPHASE>>> format
	 * @param v ArrayList of "extra" arguments
	 * @return the english corresponding to the extra arguments
	 */
	private static String parseExtras(ArrayList v) {
		String description = null;
		String s = (String)v.get(0);
		if (s.toUpperCase().matches("DC")) {
			if (v.size()>1) {
				description = " has DC value "+(String)v.get(1);
				if (v.size()>2) {
					v.remove(0);
					v.remove(0);
					String more = parseExtras(v);
					if (more == null) {
						description = null;
					} else {
						description = description + more;
					}
				}
			}
		} else if (s.toUpperCase().matches("AC") && (v.size()<=3)) {
			if (v.size()==1) {
				description = " with AC magnitude of 1 and phase 0";
			} else if (v.size()==2) {
				description = " with AC magnitude of "+(String)v.get(1)+
					" and phase 0";
			} else { // size=3
				description = " with AC magnitude of "+(String)v.get(1)+
					" and phase "+ (String)v.get(2);
			}
		} else if (v.size()==1) {
			description = " has DC value " + (String)v.get(0);
		}
		return description;
	}
}