#include <iostream>
#include <cstring>

using namespace std;

enum { STR_LEN = 50 };

class InvalidPassword {
    char text[32];
public:
    InvalidPassword(const char* text = "") {
        strcpy(this->text, text);
    }

    char *getMessage() {
        return text;
    }
};

class InvalidEmail {
    char text[32];
public:
    InvalidEmail(const char* text = "") {
        strcpy(this->text, text);
    }

    char *getMessage() {
        return text;
    }
};

class MaximumSizeLimit {
    int size;
public:
    MaximumSizeLimit(int size = 0) {
        this->size = size;
    }

    void message() {
        cout << "You can't add more than " << size << " users." << endl;
    }
};

bool isValidEmail(const char *email) {
    int n = strlen(email);
    bool valid = false;
    for(int i=0; i<n; i++) {
        if(email[i] == '@') {
            if(valid) {
                return false;
            } else valid = true;
        }
    }
    return valid;
}

bool isValidPassword(const char *pass) {
    int n = strlen(pass);
    bool upper = false, lower = false, digit = false;
    for(int i=0; i<n; i++) {
        if(isupper(pass[i])) upper = true;
        else if(islower(pass[i])) lower = true;
        else if(isdigit(pass[i])) digit = true;
    }
    return upper&&lower&&digit;
}

class User {
protected:
    char username[STR_LEN], password[STR_LEN], email[STR_LEN];
public:
    User(const char* username = "", const char* password = "", const char* email = "") {
        if(!isValidPassword(password))
            throw InvalidPassword("Password is too weak.");
        if(!isValidEmail(email))
            throw InvalidEmail("Mail is not valid.");
        strcpy(this->username, username);
        strcpy(this->password, password);
        strcpy(this->email, email);
    }

    virtual ~User() { }

    virtual double popularity() = 0;
};

class FacebookUser : public User {
    int friends, likes, comments;
    const static double likeKoef, commentKoef;
public:
    FacebookUser(const char* username = "", const char* password = "", const char* email = "",
                 int friends = 0, int likes = 0, int comments = 0) : User(username, password, email) {
        this->friends = friends;
        this->likes = likes;
        this->comments = comments;
    }

    double popularity() {
        return (friends + (likes*likeKoef) + (comments*commentKoef));
    }
};

class TwitterUser : public User {
    int followers, tweets;
    const static double tweetKoef;
public:
    TwitterUser(const char* username = "", const char* password = "", const char* email = "",
                int followers = 0, int tweets = 0) : User(username, password, email) {
        this->followers = followers;
        this->tweets = tweets;
    }

    double popularity() {
        return (followers + (tweets*tweetKoef));
    }
};

const double FacebookUser::likeKoef = 0.1;
const double FacebookUser::commentKoef = 0.5;
const double TwitterUser::tweetKoef = 0.5;

class SocialNetwork {
    User **users;
    int n;
    void copy(const SocialNetwork &sn) {
        n = sn.n;
        for(int i=0; i<n; i++) {
            users[i] = sn.users[i];
        }
    }
public:
    static int maxUsers;
    SocialNetwork() {
        n = 0;
        users = new User*[n];
    }

    SocialNetwork(const SocialNetwork &sn) {
        copy(sn);
    }

    SocialNetwork &operator=(const SocialNetwork &sn) {
        if(this == &sn) return *this;
        for(int i=0; i<n; i++)
            delete users[i];
        delete [] users;
        copy(sn);
        return *this;
    }

    SocialNetwork &operator+=(User *newUser) {
        if(n >= maxUsers)
            throw MaximumSizeLimit(maxUsers);
        User **temp = new User*[n+1];
        for(int i=0; i<n; i++) {
            temp[i] = users[i];
        }
        temp[n++] = newUser;
        delete [] users;
        users = temp;
        return *this;
    }

    double avgPopularity() {
        double sum = 0;
        for(int i=0; i<n; i++) {
            sum += users[i]->popularity();
        }
        return sum/n;
    }

    static void changeMaximumSize(int number) {
        maxUsers = number;
    }

    static int getMaxUsers() {
        return maxUsers;
    }
};

int SocialNetwork::maxUsers = 5;

int main() {


    SocialNetwork network = SocialNetwork();
    int n;
    cin >> n;
    char username[50];
    char password[50];
    char email[50];
    int userType;
    for (int i=0; i < n; ++i) {
        cin >> username;
        cin >> password;
        cin >> email;
        cin >> userType;
        if (userType == 1) {
            int friends;
            int likes;
            int comments;
            cin >> friends >> likes >> comments;

            // TODO: Try-catch
            try {
                User * u = new FacebookUser(username,password,email,friends,likes,comments);
                network += u;
            } catch(InvalidEmail &er) {
                cout << er.getMessage() << endl;
            } catch(InvalidPassword &er) {
                cout << er.getMessage() << endl;
            } catch(MaximumSizeLimit &er) {
                er.message();
            }
        } else {
            int followers;
            int tweets;
            cin >> followers >> tweets;

            // TODO: Try-catch
            try {
                User * u= new TwitterUser(username,password,email,followers,tweets);
                network += u;
            } catch(InvalidEmail &er) {
                cout << er.getMessage() << endl;
            } catch(InvalidPassword &er) {
                cout << er.getMessage() << endl;
            } catch(MaximumSizeLimit &er) {
                er.message();
            }
        }

    }

    network.changeMaximumSize(6);
    cin >> username;
    cin >> password;
    cin >> email;
    int followers;
    int tweets;
    cin >> followers >> tweets;

    // TODO: Try-catch
    try {
        User * u= new TwitterUser(username,password,email,followers,tweets);
        network += u;
    } catch(InvalidEmail &er) {
        cout << er.getMessage() << endl;
    } catch(InvalidPassword &er) {
        cout << er.getMessage() << endl;
    } catch(MaximumSizeLimit &er) {
        er.message();
    }

    cout << network.avgPopularity();
}