#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <regex>
#include <fstream>
#include <WinSock2.h>
#include <Windows.h>

#pragma comment(lib, "ws2_32.lib")

using namespace std;

void startupWSA()
{
    WSADATA wsadata;
    WSAStartup( MAKEWORD(,), &wsadata);
}

inline void cleanupWSA()
{
    WSACleanup();
}

inline pair<string, string> binaryString(const string &str, const string &dilme)
{
    pair<string, string> result(str, "");
    auto pos = str.find(dilme);
    if ( pos != string::npos )
    {
        result.first = str.substr(, pos);
        result.second = str.substr(pos + dilme.size());
    }
    return result;
}

inline string getIpByHostName(const string &hostName)
{
    hostent* phost = gethostbyname( hostName.c_str() );
    ]): "";
}

inline SOCKET connect(const string &hostName)
{
    auto ip = getIpByHostName(hostName);
    if ( ip.empty() )
        ;
    auto sock = socket(AF_INET, SOCK_STREAM, );
    if ( sock == INVALID_SOCKET )
        ;
    SOCKADDR_IN addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons();
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
    if ( connect(sock, (const sockaddr *)&addr, sizeof(SOCKADDR_IN)) == SOCKET_ERROR )
        ;
    return sock;
}

inline bool sendRequest(SOCKET sock, const string &host, const string &get)
{
    string http
        = "GET " + get + " HTTP/1.1\r\n"
        + "HOST: " + host + "\r\n"
        + "Connection: close\r\n\r\n";
    ], http.size(), );
}

inline string recvRequest(SOCKET sock)
{
    , };
     * , '\0');
    auto len = , reclen = ;
    do {
        fd_set fd = {};
        FD_SET(sock, &fd);
        reclen = ;
        , &fd, nullptr, nullptr, &wait) >  )
        {
            reclen = recv(sock, &buffer[] + len,  *  - len, );
            )
                len += reclen;
        }
        FD_ZERO(&fd);
    } );

        ? buffer[] == ] == ] == '
        ? buffer.substr(, len)
        : ""
        : "";
}

inline void extUrl(const string &buffer, queue<string> &urlQueue)
{
    if (buffer.empty())
    {
        return ;
    }
    smatch result;
    auto curIter = buffer.begin();
    auto endIter = buffer.end();
    while ( regex_search(curIter, endIter, result, regex("href=\"(https?:)?//\\S+\"") ) )
    {
        urlQueue.push(regex_replace(
            result[].str(),
            regex("href=\"(https?:)?//(\\S+)\""),
            "$2") );
        curIter = result[].second;
    }
}

void Go(const string &url, int count)
{
    queue<string> urls;
    urls.push(url);
    ; i != count; ++i)
    {
        if ( !urls.empty() )
        {
            auto &url = urls.front();
            auto pair = binaryString( url, "/" );
            auto sock = connect(pair.first);
            if ( sock && sendRequest(sock, pair.first, "/" + pair.second) )
            {
                auto buffer = move( recvRequest(sock) );
                extUrl(buffer, urls);
            }　　　　　　　closesocket(sock);
            cout << url << ": count=> " << urls.size() <<  endl;
            urls.pop();

        }
    }
}

int main()
{
    startupWSA();
    Go();
    cleanupWSA();
    ;
}