//next_permutation(x.begin(),x.end());返回当前排列字典序的下一个排列，如果已经完了的话是返回false，否则返回true
class Solution {
public:
    vector<vector<int>> permutation(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> res;
        do{
            res.push_back(nums);
        }while(next_permutation(nums.begin(),nums.end()));
        return res;
    }
};

class Solution {
public:
    int NumberOf1(int n) {
        int res=0;
        for(int i=0;i<32;i++)//int整数32位
        {
            if(n>>i&1)res++;
        }
        return res;
    }
};

class Solution {
public:
    vector<int> getLeastNumbers_Solution(vector<int> input, int k) {
        sort(input.begin(),input.end());
        vector<int> res;
        for(int i=0;i<k;i++)
        {
            res.push_back(input[i]);
        }
        return res;
    }
};

class MyQueue {
public:
    /** Initialize your data structure here. */
    stack<int> s1,s2;
    MyQueue() {
    }

    /** Push element x to the back of queue. */
    void push(int x) {
        s1.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        while(s1.size())
        {
            s2.push(s1.top());
            s1.pop();
        }
        int res=s2.top();
        s2.pop();
        while(s2.size())
        {
            s1.push(s2.top());
            s2.pop();
        }
        return res;
    }

    /** Get the front element. */
    int peek() {
        while(s1.size())
        {
            s2.push(s1.top());
            s1.pop();
        }
        int res=s2.top();
        while(s2.size())
        {
            s1.push(s2.top());
            s2.pop();
        }
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        if(!s1.size())  return true;
        else   return false;
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
using namespace std;
struct nums
{
    int x;
    double y;
    string str;
};
struct nums Array[10010];
bool cmp(struct nums a,struct nums b)
{
    return a.x<b.x;
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        cin>>Array[i].x>>Array[i].y>>Array[i].str;
    }
    sort(Array,Array+n,cmp);//sort(排序首元素的地址，尾元素的下一个地址，cmp比较函数)
    for(int i=0;i<n;i++ )
    {
        cout<<Array[i].x<<" ";
        printf("%.2lf",Array[i].y);
        cout<<" "<<Array[i].str<<endl;
    }
    return 0;
}

class Solution {
public:
    vector<int> findNumbersWithSum(vector<int>& nums, int target) {
        vector<int> res;
        for(int i=0;i<nums.size()-1;i++)
        {
            for(int j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target)
                {
                   res.push_back(nums[i]);
                   res.push_back(nums[j]);
                }
            }
        }
        return res;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        vector<int> res;
        stack<int> st;
        ListNode* p=head;
        while(p)
        {
            st.push(p->val);
            p=p->next;
        }
        while(st.size())
        {
            int temp=st.top();
            st.pop();
            res.push_back(temp);
        }
        return res;
    }
};

//归并思想
class Solution {
public:
    void reOrderArray(vector<int> &array) {
         int singlenumber[110];
         int doublenumber[110];
         int k=0,h=0;
         for(int i=0;i<array.size();i++)
         {
             if(array[i]%2!=0) singlenumber[k++]=array[i];
             else              doublenumber[h++]=array[i];
         }
         int i;
         for(i=0;i<k;i++)  array[i]=singlenumber[i];
         for(int j=i;j<i+h;j++) array[j]=doublenumber[j-i];
    }
};

//不用二分也AC
bool hashtable[1010];
class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        for(int i=0;i<nums.size();i++)
        {
            hashtable[nums[i]]=true;
        }
        for(int i=0;i<=nums.size();i++)
        {
            if(hashtable[i]==false)  return i;
        }
    }
};

//vector可以当数组用
class Solution {
public:
    int getNumberOfK(vector<int>& nums , int k) {
        int res=0;
        for(int i=0;i<nums.size();i++)
        {
            if(k==nums[i])  res++;
        }
        return res;
    }
};