#include <stdio.h>
#include <vector>
#include <list>
#include <array>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <stdexcept>


using std::string;
using std::vector;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf("%d", list[i]);
        if(i != list.size() -1){
            printf(" ");
        }
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
typedef struct _pos{
    double x;
    double y;
    _pos sub(_pos p){
        double dx = this->x - p.x;
        double dy = this->y - p.y;
        return {dx, dy};
    }
    double distance(_pos p){
        _pos d = this->sub(p);
        return std::sqrt(std::pow(d.x, 2) + std::pow(d.y, 2));
    }
    _pos add(_pos p) {
        return {p.x + this->x, p.y + this->y};
    }
    _pos div(double v){
        return { this->x / v, this->y / v};
    }
    double angle(_pos p){
        _pos diff = p.sub(*this);
        // printf("diff: %f, %f\n", diff.x, diff.y);
        return std::atan2(diff.y, diff.x);
    }
} pos;

std::vector<pos> coch(pos p1, pos p2) {
    // printf("p1: %f, %f p2: %f, %f\n", p1.x, p1.y, p2.x, p2.y);
    std::vector<pos> result(3);
    pos diff = p2.sub(p1);
    // s
    pos s = diff.div(3.0).add(p1);
    result[0] = s;
    // printf("(%lf, %lf)\n", s.x, s.y);
    // t
    pos t = diff.div(3.0/2.0).add(p1);
    result[2] = t;
    // printf("(%lf, %lf)\n", t.x, t.y);

    // u
    double a = p1.angle(p2);
    // printf("angle:%f\n", a * 360 / 2 * M_PI);
    double y = std::sin(M_PI / 3 + a) * (p2.distance(p1) / 3.0);
    double x = std::cos(M_PI / 3 + a) * (p2.distance(p1) / 3.0);
    pos u = {x + s.x, y + s.y};
    result[1] = u;
    // printf("(%lf, %lf)\n", u.x, u.y);

    return result;
}

void solve() {
    int n;
    scanf("%d", &n);

    std::list<pos> l;
    l.push_back({0.0, 0.0});
    l.push_back({100.0, 0.0});



    for(int i = 0; i < n; i++){
    //    printf("list--- ---- ---- ----\n");
    //     for(auto each : l){
    //         printf("%lf %lf\n", each.x, each.y);
    //     }

        auto it = l.begin();
        auto size = l.size();
        for(int j = 0; j < size - 1; j++) {
            pos left = *(it++);
            pos right = *(it);

            auto res = coch(left, right);
            for(auto each: res){
                // printf("insert\n");
                it = l.insert(it, each);
                it++;
            }
        }
    }

    

    // printf("result --- ---- ---- ----\n");
    for(auto each : l){
        printf("%.8f %.8f\n", each.x, each.y);
    }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
    solve();
    return 0;
}


Measured memory_bytes: 3780