import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        List<Student> students = new ArrayList<>();
        while (reader.hasNextLine()) {
            String line = reader.nextLine().trim();
            if ("end".equals(line)) {
                break;
            } else {
                String[] infos = line.split("\\s+");
                Student student = new Student(infos[0], infos[1], Integer.parseInt(infos[2]), Integer.parseInt(infos[3]));
                students.add(student);
            }
        }

        Collections.sort(students, (a, b) -> {
            int abSum = a.math + a.physic;
            int bbSum = b.math + b.physic;
            if (abSum != bbSum) {
                return bbSum - abSum;
            } else {
                return students.indexOf(a) - students.indexOf(b);
            }
        });

        for (Student student : students) {
            System.out.println(String.format("%s %s %d", student.num, student.name, student.math + student.physic));
        }
    }

    static class Student {
        String num;
        String name;
        int math;
        int physic;

        public Student(String num, String name, int math, int physic) {
            this.num = num;
            this.name = name;
            this.math = math;
            this.physic = physic;
        }
    }
}

import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {
    public static void main(String[] args) {

        // 输入数据
        Scanner scan = new Scanner(System.in);
        String str;

        HashMap<String, String> stuMap = new HashMap<>();
        while (true) {
            str = scan.nextLine();
            if (str.equalsIgnoreCase("end")) {
                break;
            }
            // 用空格拆分字符串
            String[] strArr = str.split("\\s+");
            String id = strArr[0];
            String name = strArr[1];
            String score = strArr[2];
            if (stuMap.containsKey(id)) {
                continue;
            } else {
                stuMap.put(id, name + " " + score);
            }
        }

        // 排序
        TreeMap<String, String> trMap = new TreeMap<>();
        for (String key : stuMap.keySet()) {
            String value = stuMap.get(key);
            trMap.put(key, value);
        }

        // 输出结果

        for (String key : trMap.descendingKeySet()) {
            String value = trMap.get(key);
            System.out.println(key + " " + value);
        }
    }
}

import java.util.*;
public class Main {
    // 关键字列表
    private static final Set<String> KEYWORDS = new HashSet<>(Arrays.asList(
            "abstract", "assert", "boolean",
                "break", "byte", "case", "catch", "char", "class", "const",
                "continue", "default", "do", "double", "else", "enum",
                "extends", "for", "final", "finally", "float", "goto",
                "if", "implements", "import", "instanceof", "int",
                "interface", "long", "native", "new", "package", "private",
                "protected", "public", "return", "short", "static",
                "strictfp", "super", "switch", "synchronized", "this",
                "throw", "throws", "transient", "try", "void", "volatile",
                "while", "true", "false", "null"));
    // 分隔符列表
    private static final Set<String> SEPARATORS = new HashSet<>(Arrays.asList(
            " ", ";", "\n", "\t", ",", ".", "(", ")", "{", "}", "[", "]"));
    public static void main(String[] args) {
        // 读取输入并构造字符串
        Scanner sc = new Scanner(System.in);
        StringBuilder strBuilder = new StringBuilder();
        while (true) {
            String str = sc.nextLine().trim();
            if ("exit".equals(str)) {
                break;
            }
            strBuilder.append(str).append("\n");
        }
        String code = strBuilder.toString().trim();
        // 字符串为空，输出错误信息
        if (code.isEmpty()) {
            System.out.println("Wrong Format");
            return;
        }
        // 计数器map
        Map<String, Integer> cnt = new TreeMap<>();// 用于标记是否正在注释或字符串中，以及缓存正在读取的单词
        boolean inAnnotation = false;
        boolean inString = false;
        StringBuilder wordBuilder = new StringBuilder();// 遍历所有字符
        for (int i = 0; i < code.length(); i++) {
            char c = code.charAt(i);
            // 不在注释和字符串中
            if (!inAnnotation && !inString) {
                if (c == '/') { // 检测是否为注释符号
                    if (i + 1 < code.length()) {
                        char nextChar = code.charAt(i + 1);
                        if (nextChar == '/') { // 行注释
                            while (i < code.length() && code.charAt(i) != '\n') { // 跳到下一行
                                i++;
                            }
                        } else if (nextChar == '*') { // 块注释
                            inAnnotation = true;
                            i++;
                        }
                    }
                } else if (c == '"') { // 字符串
                    inString = true;
                    wordBuilder.append(c);
                } else if (SEPARATORS.contains(String.valueOf(c))) { // 分隔符
                    if (!wordBuilder.toString().isEmpty()) {
                        String word = wordBuilder.toString();
                        wordBuilder = new StringBuilder();
                        if (KEYWORDS.contains(word)) {
                            cnt.put(word, cnt.getOrDefault(word, 0) + 1); // 计数
                        }
                    }
                } else {
                    wordBuilder.append(c);
                }
            }// 在块注释中
            else if (inAnnotation) {
                if (c == '*' && i + 1 < code.length() && code.charAt(i + 1) == '/') { // 注释结束
                    inAnnotation = false;
                    i++;
                }
            }// 在字符串中
            else if (inString) {
                wordBuilder.append(c);
                if (c == '"' && i > 0 && code.charAt(i - 1) != '\\') { // 字符串结束
                    inString = false;
                    String word = wordBuilder.toString();
                    wordBuilder = new StringBuilder();
                    if (KEYWORDS.contains(word)) {
                        cnt.put(word, cnt.getOrDefault(word, 0) + 1); // 计数
                    }
                }
            }
        }
        // 处理最后一个单词
        if (!inAnnotation && !inString && !wordBuilder.toString().isEmpty()) {
            String word = wordBuilder.toString();
            if (KEYWORDS.contains(word)) {
                cnt.put(word, cnt.getOrDefault(word, 0) + 1);
            }
        }// 输出结果
        for (Map.Entry<String, Integer> entry : cnt.entrySet()) {
            System.out.println(entry.getValue() + "\t" + entry.getKey());
        }
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        ArrayList students = new ArrayList<>();
        ArrayList courses = new ArrayList<>();
        ArrayList chooseCourses = new ArrayList<>();
        ArrayList classes = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt(); // 学生个数
        scanner.nextLine(); // 读取换行符
        for (int i = 0; i < n; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            Student student = new Student(parts[0], parts[1]);
            students.add(student);
        }

        int m = scanner.nextInt(); // 课程个数
        scanner.nextLine(); // 读取换行符
        for (int i = 0; i < m; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            Course course = new Course(parts[0], parts[1], parts[2]);
            courses.add(course);
        }

        int k = scanner.nextInt(); // 选课个数
        scanner.nextLine(); // 读取换行符
        for (int i = 0; i < k; i++) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            Student student = null;
            Course course = null;
            for (Student stu : students) {
                if (stu.getNumber().equals(parts[0])) {
                    student = stu;
                    break;
                }
            }
            for (Course cou : courses) {
                if (cou.getCourseName().equals(parts[1])) {
                    course = cou;
                    break;
                }
            }
            ChooseCourse chooseCourse = new ChooseCourse(student, course);
            chooseCourses.add(chooseCourse);
        }

        for (ChooseCourse chooseCourse : chooseCourses) {
            String line = scanner.nextLine();
            String[] parts = line.split(" ");
            int usualPerformance = Integer.parseInt(parts[0]);
            int finalScore = Integer.parseInt(parts[1]);
            TextScore textScore = new TextScore(usualPerformance, finalScore);
            chooseCourse.setScore(textScore);
        }

        for (Student student : students) {
            ArrayList<Course> studentCourses = new ArrayList<>();
            for (ChooseCourse chooseCourse : chooseCourses) {
                if (chooseCourse.getStudent().equals(student)) {
                    studentCourses.add(chooseCourse.getCourse());
                }
            }
            Class cl = new Class();
            cl.setAllStudents(students);
            cl.setStudentNumber(new int[students.size()]);
            cl.setCourseNumber(new int[courses.size()]);
            cl.setCourses(studentCourses);
            classes.add(cl);
            cl.initScoreArray(chooseCourses);
        }

        for (Class cl : classes) {
            cl.calculateCoursesAverageScore();
            int classTotalScore = cl.calculateClassTotalScore();
            int classAverageScore = cl.calculateClassAverageScore();

            // 输出班级总分和平均分
            System.out.println(classTotalScore + " " + classAverageScore);

            // 输出每位学生的排名和总分
            for (int i = 0; i < students.size(); i++) {
                int rank = 1;
                for (int j = 0; j < students.size(); j++) {
                    if (cl.getStudentScores().get(i) < cl.getStudentScores().get(j)) {
                        rank++;
                    }
                }
                System.out.println(cl.getStudentNumber()[i] + " " + rank + " " + cl.getStudentScores().get(i));
            }

            // 输出每门课程的平均分
            for (int i = 0; i < cl.getCourses().size(); i++) {
                System.out.println(cl.getCourses().get(i).getCourseName() + " " + cl.getCoursesAverageScore().get(i));
            }
        }
    }
}

class Student {
    private String number;
    private String name;

    public Student(String number, String name) {
        this.number = number;
        this.name = name;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Class {
    private ArrayList allStudents = new ArrayList<>();
    private ArrayList chooseCourses = new ArrayList<>();
    private ArrayList courses = new ArrayList<>();
    private ArrayList coursesAverageScore = new ArrayList<>();
    private ArrayList studentScores = new ArrayList<>();
    private int[] studentNumber;
    private int[] courseNumber;

    public void calculateCoursesAverageScore() {
        for (int i = 0; i < courses.size(); i++) {
            int sum = 0;
            int count = 0;
            for (ChooseCourse chooseCourse : chooseCourses) {
                if (chooseCourse.getCourse().equals(courses.get(i))) {
                    Score score = chooseCourse.getScore();
                    if (score instanceof TextScore) {
                        sum += score.calculateTotalScore();
                        count++;
                    }
                }
            }
            int averageScore = (count > 0) ? Math.round(sum / count) : 0;
            coursesAverageScore.add(averageScore);
        }
    }

    public int calculateClassTotalScore() {
        int totalScore = 0;
        for (int score : studentScores) {
            totalScore += score;
        }
        return totalScore;
    }

    public int calculateClassAverageScore() {
        if (allStudents.isEmpty()) {
            return 0;
        } else {
            return calculateClassTotalScore() / allStudents.size();
        }
    }

    public void initScoreArray(ArrayList<ChooseCourse> chooseCourses) {
        this.chooseCourses = chooseCourses;
        studentNumber = new int[allStudents.size()];
        for (int i = 0; i < studentNumber.length; i++) {
            studentNumber[i] = Integer.parseInt(allStudents.get(i).getNumber());
        }
        courseNumber = new int[courses.size()];
        for (int i = 0; i < courseNumber.length; i++) {
            courseNumber[i] = i + 1;
        }
        for (int i = 0; i < allStudents.size(); i++) {
            int totalScore = 0;
            for (int j = 0; j < courses.size(); j++) {
                ChooseCourse chooseCourse = getChooseCourse(allStudents.get(i), courses.get(j));
                if (chooseCourse != null) {
                    Score score = chooseCourse.getScore();
                    if (score instanceof NormalScore) { // 不计入总分的成绩不计入总分
                        totalScore += 0;
                    } else if (score instanceof TextScore) {
                        totalScore += score.calculateTotalScore();
                    }
                }
            }
            studentScores.add(totalScore);
        }
    }

    private ChooseCourse getChooseCourse(Student student, Course course) {
        for (ChooseCourse chooseCourse : chooseCourses) {
            if (chooseCourse.getStudent().equals(student) &&
                    chooseCourse.getCourse().equals(course)) {
                return chooseCourse;
            }
        }
        return null;
    }

    public ArrayList<Student> getAllStudents() {
        return allStudents;
    }

    public void setAllStudents(ArrayList<Student> allStudents) {
        this.allStudents = allStudents;
    }

    public ArrayList<Course> getCourses() {
        return courses;
    }

    public void setCourses(ArrayList<Course> courses) {
        this.courses = courses;
    }

    public int[] getStudentNumber() {
        return studentNumber;
    }

    public void setStudentNumber(int[] studentNumber) {
        this.studentNumber = studentNumber;
    }

    public int[] getCourseNumber() {
        return courseNumber;
    }

    public void setCourseNumber(int[] courseNumber) {
        this.courseNumber = courseNumber;
    }

    public ArrayList<Integer> getCoursesAverageScore() {
        return coursesAverageScore;
    }

    public ArrayList<Integer> getStudentScores() {
        return studentScores;
    }
}

class Course {
    private String courseName;
    private String examWay;
    private String type;

    public Course(String courseName, String examWay, String type) {
        this.courseName = courseName;
        this.examWay = examWay;
        this.type = type;
    }

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public String getExamWay() {
        return examWay;
    }

    public void setExamWay(String examWay) {
        this.examWay = examWay;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

class NormalScore extends Score {

    public NormalScore(int Score) {
        setTotalScore(Score);
    }

    @Override
    public int calculateTotalSore() {
        return getTotalScore(); // 普通成绩的总分就是totalScore
    }
}

abstract class Score {
    private int finalSore = 0;
    private int totalScore = 0;

    public abstract int calculateTotalSore();

    public int getFinalSore() {
        return finalSore;
    }

    public void setFinalSore(int finalSore) {
        this.finalSore = finalSore;
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(int totalScore) {
        this.totalScore = totalScore;
    }
}

class TextScore extends Score {
    private int usualPerformance = 0;

    public TextScore(int usualPerformance, int finalScore) {
        setUsualPerformance(usualPerformance);
        setFinalScore(finalScore);
    }

    public int getUsualPerformance() {
        return usualPerformance;
    }

    public void setUsualPerformance(int usualPerformance) {
        this.usualPerformance = usualPerformance;
    }

    public int getFinalScore() {
        return getFinalSore();
    }

    public void setFinalScore(int finalScore) {
        setFinalSore(finalScore);
    }

    @Override
    public int calculateTotalSore() {
        return (int) Math.round(getUsualPerformance() * 0.3 + getFinalScore() * 0.7);
    }
}