#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <algorithm>
#include <immintrin.h>
#include <string.h>
#include <xmmintrin.h>
using MINT = int32_t;
constexpr size_t no_players = 416;
constexpr size_t max_marble = 7161700;

template<typename T, size_t growth_factor>
struct container{
    std::vector<T> data;
    std::vector<T> data_new;
    size_t pos = 0;
    container() : data(growth_factor){
        std::fill(data.begin(), data.end(), -1);
        data[pos] = 0;
        pos += growth_factor/2;
        data[pos] = 1;
        data.reserve(8000000);
        data_new.reserve(8000000);
    }

    void resize(){
        size_t pos_new;
        data_new.reserve(data.size() * growth_factor);
        for(size_t i = 0; i < data.size(); i++){
            if(data[i] != -1){
                data_new.push_back(data[i]);
                if(pos == i){
                    pos_new = data_new.size() - 1;
                }
                for(size_t j = 0; j < growth_factor; j++){
                    data_new.push_back(-1);
                }
            }
        }
        pos = pos_new;
        std::swap(data, data_new);
        data_new.erase(data_new.begin(), data_new.end());
        //data = std::move(data_new);
    }

    void seek_previous(){
        while(pos > 0){
            pos--;
            if(data[pos] != -1){
                return;
            }
        }
        pos = data.size() - 1;
        seek_previous();
    }

    void seek_next(){
        while(pos < data.size() - 1){
            pos++;
            if(data[pos] != -1){
                return;
            }
        }
        pos = 0;
        if(data[pos] != -1){
            return;
        }
        seek_next();
    }



    void insert(T value){
        size_t tmp_pos = pos;
        seek_next();
        size_t lower = pos;
        seek_next();
        size_t upper = pos;
        if(lower > upper){
            if(lower == data.size() - 1){
                pos = tmp_pos;
                resize();
                insert(value);
                return;
            }
            else{
                size_t diff = (data.size() - 1) - lower;
                if(diff == 1){
                    pos = data.size() - 1;
                    data[pos] = value;
                    return;
                }
                else{
                    size_t pnew = lower + diff / 2;
                    data[pnew] = value;
                    pos = pnew;
                    return;
                }
            }
        }
        else{
            size_t diff = upper-lower;
            if(diff == 1){
                pos = tmp_pos;
                resize();
                insert(value);
                return;
            }
            size_t pnew = lower + diff / 2;
            data[pnew] = value;
            pos = pnew;
        }
    }

    T remove(){
        for(size_t i = 0; i < 7; i++){
            seek_previous();
        }
        T value = data[pos];
        data[pos] = -1;
        seek_next();
        return value;
    }

    void print(bool print_empty = false){
        for(auto i : data){
            if(i!=-1 or print_empty)
                std::cout<<i<<" ";
        }
        std::cout<<std::endl;
    }


};


int main(){
    for(size_t i = 0; i<20; i++){
        container<MINT, 3> marbles;
        std::array<int64_t, no_players> scores = {0};

        MINT marb = 2;

        while(true){
            if(marb % 23 == 0){
                scores[marb % no_players] += marb + marbles.remove();
            }
            else{
                marbles.insert(marb);
            }

            marb++;
            if(marb == max_marble){
                auto max = *std::max_element(scores.begin(), scores.end());
                std::cout<<max<<std::endl;
                break;
            }
        }
    }

}