"osu_v2api_client_id": 1234,

     "osu_v2api_client_secret": "get it here: https://osu.ppy.sh/home/account/edit#new-oauth-application",

     "max_lobbies": 1,

     "CONNECT_TO_DISCORD": false,

     "discord_admin": "889603773574578198",

     user_id        INTEGER NOT NULL,

     mode           INTEGER NOT NULL, -- 0 = std, 1 = taiko, 2 = ctb, 3 = mania

     total_scores   INTEGER NOT NULL,

     elo            REAL    NOT NULL,

     division       TEXT    NOT NULL,

 const get_rating_stmt = db.prepare(`SELECT * FROM rating WHERE user_id = ? AND mode = ?`);

 const update_rating_stmt = db.prepare(`

   UPDATE rating SET

     total_scores = ?,

     elo = ?

   WHERE user_id = ? AND mode = ?`,

 );

 const better_users_stmt = db.prepare(`

   SELECT COUNT(*) AS nb FROM rating r1, rating r2

     AND r1.elo > r2.elo AND r2.user_id = ?`,

 );

 const nb_active_users = [

   nb_active_users_stmt.get(Config.games_needed_for_rank, 0).nb,

   nb_active_users_stmt.get(Config.games_needed_for_rank, 1).nb,

       player.expected += 1 / (1 + Math.pow(10, (opponent.rating.elo - player.rating.elo) / 480));

     }

     player.new_elo = player.rating.elo + k_factor * (player.actual - player.expected);

     if (player.new_elo < 100) player.new_elo = 100;

     );

     // score.rating is cached, so updating it here

     score.rating.total_scores++;

     score.rating.elo = score.new_elo;

     // We also cache the total number of active users for each ruleset :)

       nb_active_users[score.rating.mode]++;

     }

     update_rating_stmt.run(

         score.rating.total_scores,

         score.rating.elo,

         score.rating.user_id,

   const rank_changes = [];

   for (const score of game.scores) {

     const player = await get_user_by_id(score.user_id);

     const old_rank_text = player.ratings[game.mode_int].division;

     const new_rank_text = get_division_from_elo(score.rating.elo, game.mode_int);

       Config.games_needed_for_rank, ruleset,

       user_id,

   );

   const info = {

     elo: '???',

     rank_nb: '???',

     text: 'Unranked',

     total_scores: rating.total_scores,

     is_ranked: is_ranked,

   };

 function update_the_one(user_id, elo, mode) {

   // Check that "The One" is not deranking after a loss

   if (user_id == the_ones[mode].user_id) {

     division_floors[mode][divisions.length - 1] = the_one.elo;

     the_ones[mode] = {

       user_id: the_one.user_id,

   const nb_divisions = divisions.length - 1;

   for (let j = 0; j < 4; j++) {

     // Really stupid query but that's the fastest way I found...

     for (let i = 1; i < nb_divisions; i++) {

       // Turn current division into a value between 0 and 1

       const rank_nb = i / nb_divisions;

   // Update floor for 'The One'

   for (let i = 0; i < 4; i++) {

     division_floors[i][nb_divisions] = the_one.elo;

     the_ones[i] = {

       user_id: the_one.user_id,

     location ~ \.(?:ico|png|css|js|webmanifest)(?:\?\d+)?$ {

         root /path/to/the/repository/osu-ranked-lobbies/public;

     }

     location / {

 async function init_user(user_id) {

   for (let ruleset = 0; ruleset < 4; ruleset++) {

     db.prepare(`INSERT INTO

       RETURNING *`,

     ).run(user_id, ruleset);

   }

       </svg>`;

   }

   rankup_percent = Math.round(rankup_percent * 100);

 %>

   const PLAYERS_PER_PAGE = 20;

   const active_users = get_active_users(mode);

   // Fix user-provided page number

   const nb_pages = Math.ceil(active_users / PLAYERS_PER_PAGE);

   const res = db.prepare(`

     SELECT user.user_id, country_code, username, elo FROM user

     INNER JOIN rating ON user.user_id = rating.user_id

     ORDER BY elo DESC LIMIT ? OFFSET ?`,

   ).all(Config.games_needed_for_rank, mode, PLAYERS_PER_PAGE, offset);

   app.all('/api/leaderboard/:pageNum/', async (req, http_res) => {

     try {

       const data = await get_leaderboard_page(get_mode(req), parseInt(req.params.pageNum, 10));

       http_res.json(data);

     } catch (err) {

       http_res.status(err.http_code || 503).json({error: err.message});

   app.all('/api/user/:userId/', async (req, http_res) => {

     try {

       const data = await get_user_profile(parseInt(req.params.userId, 10), get_mode(req));

       http_res.json(data);

     } catch (err) {

       http_res.status(err.http_code || 503).json({error: err.message});

           get_mode(req),

           parseInt(req.params.pageNum, 10),

       );

       http_res.json(data);

     } catch (err) {

       http_res.status(err.http_code || 503).json({error: err.message});

 const user_not_found_page = base.replace('<%~ it.body %>', 'User not found.'); // TODO better looking page

 const faq_page = eta.render('faq.eta');

 const js_page = eta.render('jspage.eta');

 function mini_cache(res) {

   if (!Config.IS_PRODUCTION) return;

   // Cache that only lasts 10 seconds, to reduce load while still keeping content fresh

 }

 function get_mode(req) {

   mini_cache(res);

   const data = await get_leaderboard_page(get_mode(req), page_num);

   for (const player of data.players) {

     player.flag = country_code_to_flag_html(player.country_code);

   }