package com.company.mankind;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class MainMankind {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String[] student = reader.readLine().split("\\s+");
        String firstName = student[0];
        String lastName = student[1];
        String facultyNumber = student[2];

        String[] worker = reader.readLine().split("\\s+");
        String firstNameWorker = worker[0];
        String lastNameWorker = worker[1];
        double salary = Double.parseDouble(worker[2]);
        double workingHours = Double.parseDouble(worker[3]);

        try {
            Human student1 = new Student(firstName, lastName, facultyNumber);
            Human worker1 = new Worker(firstNameWorker, lastNameWorker, salary, workingHours);
            System.out.println(student1.toString());
            System.out.println(worker1.toString());
        } catch (IllegalArgumentException ex) {
            System.out.println(ex.getMessage());
            return;
        }
    }
}
//Human
public class Human {
    private static final int FIRST_NAME_LENGTH = 4;

    private String firstName;
    private String lastName;

    public Human(String firstName, String lastName) {
        this.setFirstName(firstName);
        this.setLastName(lastName);
    }

    protected void setFirstName(String firstName) {
        char[] fName = firstName.toCharArray();
        if (Character.toLowerCase(fName[0]) == fName[0]) {
            throw new IllegalArgumentException("Expected upper case letter! Argument: firstName");
        }
        if (firstName.length() < FIRST_NAME_LENGTH) {
            throw new IllegalArgumentException("Expected length at least 4 symbols! Argument: firstName");
        }

        this.firstName = firstName;
    }

    protected void setLastName(String lastName) {
        char[] lName = lastName.toCharArray();
        if (Character.toLowerCase(lName[0]) == lName[0]) {
            throw new IllegalArgumentException("Expected upper case letter! Argument: lastName");
        }

        this.lastName = lastName;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("First Name: %s%n", this.firstName));
        sb.append(String.format("Last Name: %s%n", this.lastName));
        return sb.toString();

    }
}
//Student
public class Student extends Human {
    private static final int FACULTY_NUMBER_MIN = 5;
    private static final int FACULTY_NUMBER_MAX = 10;
    private static final int LAST_NAME_LENGTH = 3;

    private String facultyNumber;

    public Student(String firstName, String lastName, String facultyNumber) {
        super(firstName, lastName);
        this.setFacultyNumber(facultyNumber);
    }

    protected void setFacultyNumber(String facultyNumber) {
        if (facultyNumber.length() < FACULTY_NUMBER_MIN || facultyNumber.length() > FACULTY_NUMBER_MAX) {
            throw new IllegalArgumentException("Invalid faculty number!");
        }
        char[] chars = facultyNumber.toCharArray();
        for (char aChar : chars) {
            if (!Character.isLetterOrDigit(aChar)) {
                throw new IllegalArgumentException("Invalid faculty number!");
            }
        }
        this.facultyNumber = facultyNumber;
    }

    @Override
    protected void setLastName(String lastName) {
        if (lastName.length() < LAST_NAME_LENGTH) {
            throw new IllegalArgumentException("Expected length at least 3 symbols! Argument: lastName");
        }
        super.setLastName(lastName);
    }

    @Override
    public String toString() {

        StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append(String.format("Faculty number: %s%n", this.facultyNumber));
        return sb.toString();
    }
}
//Worker
public class Worker extends Human {
    private static final int LAST_NAME_LENGTH = 4;
    private static final double WEEK_SALARY_MIN = 10;
    private static final double WORK_HOURS_PER_DAY_MIN = 1;
    private static final double WORK_HOURS_PER_DAY_MAX = 12;
    private static final double DAYS_OF_WEEK = 7;
    private double weekSalary;
    private double workHoursPerDay;

    public Worker(String firstName, String lastName, double weekSalary, double workHoursPerDay) {
        super(firstName, lastName);
        this.setWeekSalary(weekSalary);
        this.setWorkHoursPerDay(workHoursPerDay);
    }

    @Override
    protected void setLastName(String lastName) {
        if (lastName.length() < LAST_NAME_LENGTH) {
            throw new IllegalArgumentException("Expected length more than 3 symbols! Argument: lastName");
        }
        super.setLastName(lastName);
    }

    protected void setWeekSalary(double weekSalary) {
        if (weekSalary <= WEEK_SALARY_MIN) {
            throw new IllegalArgumentException("Expected value mismatch! Argument: weekSalary");
        }
        this.weekSalary = weekSalary;
    }

    protected void setWorkHoursPerDay(double workHoursPerDay) {
        if (workHoursPerDay <= WORK_HOURS_PER_DAY_MIN || workHoursPerDay > WORK_HOURS_PER_DAY_MAX) {
            throw new IllegalArgumentException("Expected value mismatch! Argument: workHoursPerDay");
        }
        this.workHoursPerDay = workHoursPerDay;
    }

    public double calculateMoneyPerHour() {
        return this.weekSalary / (this.workHoursPerDay * DAYS_OF_WEEK);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append(String.format("Week Salary: %.2f%n", this.weekSalary));
        sb.append(String.format("Hours per day: %.2f%n", this.workHoursPerDay));
        sb.append(String.format("Salary per hour: %.2f%n", this.calculateMoneyPerHour()));

        return sb.toString();
    }
}