routes

# Lobby
GET   /                                controllers.Lobby.home
GET   /lobby/seeks                     controllers.Lobby.seeks

# Should be handled by nginx mostly
OPTIONS /                              controllers.Options.root
OPTIONS /*url                          controllers.Options.all(url: String)

# Timeline
GET   /timeline                        controllers.Timeline.home
POST  /timeline/unsub/:channel         controllers.Timeline.unsub(channel: String)

# Search
GET   /games/search                    controllers.Search.index(page: Int ?= 1)

# Game export
POST  /games/export/_ids               controllers.Game.exportByIds
GET   /games/export/:username          controllers.Game.exportByUser(username: String)

# Bookmark
POST  /bookmark/$gameId<\w{8}>         controllers.Game.bookmark(gameId: String)

# TV
GET   /tv                              controllers.Tv.index
GET   /tv/frame                        controllers.Tv.frame
GET   /tv/feed                         controllers.Tv.feed
GET   /tv/channels                     controllers.Main.movedPermanently(to: String = "/api/tv/channels")
GET   /tv/:chanKey                     controllers.Tv.onChannel(chanKey: String)
GET   /tv/$gameId<\w{8}>/$color<white|black>/sides controllers.Tv.sides(gameId: String, color: String)
GET   /games                           controllers.Tv.games
GET   /games/:chanKey                  controllers.Tv.gamesChannel(chanKey: String)
GET   /api/tv/channels                 controllers.Tv.channels

# Relation
POST  /rel/follow/:userId              controllers.Relation.follow(userId: String)
POST  /rel/unfollow/:userId            controllers.Relation.unfollow(userId: String)
POST  /rel/block/:userId               controllers.Relation.block(userId: String)
POST  /rel/unblock/:userId             controllers.Relation.unblock(userId: String)
GET   /@/:username/following           controllers.Relation.following(username: String, page: Int ?= 1)
GET   /@/:username/followers           controllers.Relation.followers(username: String, page: Int ?= 1)
GET   /rel/blocks                      controllers.Relation.blocks(page: Int ?= 1)

# Insight
POST  /insights/refresh/:username      controllers.Insight.refresh(username: String)
POST  /insights/data/:username         controllers.Insight.json(username: String)
GET   /insights/:username              controllers.Insight.index(username: String)
GET   /insights/:username/:metric/:dimension controllers.Insight.path(username: String, metric: String, dimension: String, filters: String = "")
GET   /insights/:username/:metric/:dimension/*filters controllers.Insight.path(username: String, metric: String, dimension: String, filters: String)

# User subpages
GET   /@/:username/tournaments/:path   controllers.UserTournament.path(username: String, path: String, page: Int ?= 1)

# User
GET   /api/stream/:username/mod        controllers.User.mod(username: String)
POST  /@/:username/note                controllers.User.writeNote(username: String)
POST  /note/delete/:id                 controllers.User.deleteNote(id: String)
GET   /@/:username/mini                controllers.User.showMini(username: String)
GET   /@/:username/tv                  controllers.User.tv(username: String)
GET   /@/:username/perf/:perfKey       controllers.User.perfStat(username: String, perfKey: String)
GET   /@/:username/all                 controllers.User.gamesAll(username: String, page: Int ?= 1)
GET   /@/:username/:filterName         controllers.User.games(username: String, filterName: String, page: Int ?= 1)
GET   /@/:username                     controllers.User.show(username: String)
GET   /player/myself                   controllers.User.myself
GET   /player/opponents                controllers.User.opponents
GET   /player                          controllers.User.list
GET   /player/top/:nb/:perfKey         controllers.User.topNb(nb: Int, perfKey: String)
GET   /player/top/week                 controllers.User.topWeek
GET   /player/online                   controllers.User.online
GET   /player/autocomplete             controllers.User.autocomplete

GET   /dasher                          controllers.Dasher.get

# Blog
GET   /blog                            controllers.Blog.index(page: Int ?= 1)
GET   /blog/all                        controllers.Blog.all
GET   /blog/:year                      controllers.Blog.year(year: Int)
GET   /blog/discuss/:id                controllers.Blog.discuss(id: String)
GET   /blog/:id/:slug                  controllers.Blog.show(id: String, slug: String, ref: Option[String] ?= None)
GET   /blog.atom                       controllers.Blog.atom
GET   /blog.txt                        controllers.Blog.sitemapTxt

# Training - Coordinate
GET   /training/coordinate             controllers.Coordinate.home
POST  /training/coordinate/score       controllers.Coordinate.score
POST  /training/coordinate/color       controllers.Coordinate.color

# Training - Puzzle
GET   /training                        controllers.Puzzle.home
GET   /training/daily                  controllers.Puzzle.daily
GET   /training/frame                  controllers.Puzzle.frame
GET   /training/export/gif/thumbnail/:id.gif controllers.Export.puzzleThumbnail(id: String)
GET   /training/themes                 controllers.Puzzle.themes
GET   /training/of-player              controllers.Puzzle.ofPlayer(name: Option[String] ?= None, page: Int ?= 1)
GET   /training/dashboard/$days<\d+>   controllers.Puzzle.dashboard(days: Int, path: String = "home")
GET   /training/dashboard/$days<\d+>/:path  controllers.Puzzle.dashboard(days: Int, path: String)
GET   /training/replay/$days<\d+>/:theme controllers.Puzzle.replay(days: Int, theme: String)
GET   /training/history                controllers.Puzzle.history(page: Int ?= 1)
GET   /training/batch                  controllers.Puzzle.mobileBcBatchSelect
POST  /training/batch                  controllers.Puzzle.mobileBcBatchSolve
GET   /training/new                    controllers.Puzzle.mobileBcNew
GET   /training/$numericalId<\d{6,}>/load      controllers.Puzzle.mobileBcLoad(numericalId: Long)
POST  /training/$numericalId<\d{6,}>/vote      controllers.Puzzle.mobileBcVote(numericalId: Long)
GET   /training/:themeOrId             controllers.Puzzle.show(themeOrId: String)
GET   /training/:theme/$id<\w{5}>      controllers.Puzzle.showWithTheme(theme: String, id: String)
POST  /training/$numericalId<\d{6,}>/round2    controllers.Puzzle.mobileBcRound(numericalId: Long)
POST  /training/$id<\w{5}>/vote        controllers.Puzzle.vote(id: String)
POST  /training/$id<\w{5}>/vote/:theme controllers.Puzzle.voteTheme(id: String, theme: String)
POST  /training/complete/:theme/$id<\w{5}>  controllers.Puzzle.complete(theme: String, id: String)
POST  /training/difficulty/:theme      controllers.Puzzle.setDifficulty(theme: String)

# Puzzle Streak
GET   /streak                           controllers.Puzzle.streak

# Puzzle Storm
GET   /storm                            controllers.Storm.home
POST  /storm                            controllers.Storm.record
GET   /storm/dashboard                  controllers.Storm.dashboard(page: Int ?= 1)
GET   /storm/dashboard/:username        controllers.Storm.dashboardOf(username: String, page: Int ?= 1)
GET   /api/storm/dashboard/:username    controllers.Storm.apiDashboardOf(username: String, days: Int ?= 30)

# Puzzle Racer
GET   /racer                            controllers.Racer.home
POST  /racer                            controllers.Racer.create
GET   /racer/:id                        controllers.Racer.show(id: String)
GET   /racer/:id/rematch                controllers.Racer.rematch(id: String)
POST  /racer/lobby                      controllers.Racer.lobby

# User Analysis
GET   /analysis/help                   controllers.UserAnalysis.help
GET   /analysis/*something             controllers.UserAnalysis.parseArg(something: String)
GET   /analysis                        controllers.UserAnalysis.index
POST  /analysis/pgn                    controllers.UserAnalysis.pgn

# Study
GET   /study                           controllers.Study.allDefault(page: Int ?= 1)
GET   /study/all/:order                controllers.Study.all(order: String, page: Int ?= 1)
GET   /study/mine/:order               controllers.Study.mine(order: String, page: Int ?= 1)
GET   /study/member/:order             controllers.Study.mineMember(order: String, page: Int ?= 1)
GET   /study/public/:order             controllers.Study.minePublic(order: String, page: Int ?= 1)
GET   /study/private/:order            controllers.Study.minePrivate(order: String, page: Int ?= 1)
GET   /study/likes/:order              controllers.Study.mineLikes(order: String, page: Int ?= 1)
GET   /study/by/:username              controllers.Study.byOwnerDefault(username: String, page: Int ?= 1)
GET   /study/by/:username/:order       controllers.Study.byOwner(username: String, order: String, page: Int ?= 1)
GET   /study/search                    controllers.Study.search(q: String ?= "", page: Int ?= 1)
GET   /study/$id<\w{8}>                controllers.Study.show(id: String)
POST  /study                           controllers.Study.create
POST  /study/as                        controllers.Study.createAs
GET   /study/$id<\w{8}>.pgn            controllers.Study.pgn(id: String)
GET   /study/$id<\w{8}>/$chapterId<\w{8}>.pgn controllers.Study.chapterPgn(id: String, chapterId: String)
GET   /study/$id<\w{8}>/$chapterId<\w{8}>.gif controllers.Study.chapterGif(id: String, chapterId: String)
POST  /study/$id<\w{8}>/delete         controllers.Study.delete(id: String)
GET   /study/$id<\w{8}>/clone          controllers.Study.cloneStudy(id: String)
POST  /study/$id<\w{8}>/cloneApply     controllers.Study.cloneApply(id: String)
GET   /study/$id<\w{8}>/$chapterId<\w{8}>        controllers.Study.chapter(id: String, chapterId: String)
GET   /study/$id<\w{8}>/$chapterId<\w{8}>/meta   controllers.Study.chapterMeta(id: String, chapterId: String)
GET   /study/embed/$id<\w{8}>/$chapterId<\w{8}>  controllers.Study.embed(id: String, chapterId: String)
POST  /study/$id<\w{8}>/clear-chat     controllers.Study.clearChat(id: String)
POST  /study/$id<\w{8}>/import-pgn     controllers.Study.importPgn(id: String)
GET   /study/$id<\w{8}>/multi-board    controllers.Study.multiBoard(id: String, page: Int ?= 1)
POST  /study/$id<\w{8}>/admin          controllers.Study.admin(id: String)
GET   /study/topic                     controllers.Study.topics
POST  /study/topic                     controllers.Study.setTopics
GET   /study/topic/:topic/:order       controllers.Study.byTopic(topic: String, order: String, page: Int ?= 1)
GET   /study/topic/autocomplete        controllers.Study.topicAutocomplete

# Relay
GET   /broadcast                           controllers.Relay.index(page: Int ?= 1)
GET   /broadcast/new                       controllers.Relay.form
POST  /broadcast/new                       controllers.Relay.create
GET   /broadcast/:slug/$id<\w{8}>          controllers.Relay.show(slug: String, id: String)
GET   /broadcast/:slug/$id<\w{8}>/$chapterId<\w{8}> controllers.Relay.chapter(slug: String, id: String, chapterId: String)
GET   /broadcast/:slug/$id<\w{8}>/edit     controllers.Relay.edit(slug: String, id: String)
POST  /broadcast/:slug/$id<\w{8}>/edit     controllers.Relay.update(slug: String, id: String)
POST  /broadcast/:slug/$id<\w{8}>/reset    controllers.Relay.reset(slug: String, id: String)
POST  /broadcast/:slug/$id<\w{8}>/clone    controllers.Relay.cloneRelay(slug: String, id: String)
POST  /broadcast/:slug/$id<\w{8}>/push     controllers.Relay.push(slug: String, id: String)

# Learn
GET   /learn                           controllers.Learn.index
POST  /learn/score                     controllers.Learn.score
POST  /learn/reset                     controllers.Learn.reset

# Patron
GET   /patron                          controllers.Plan.index
GET   /patron/thanks                   controllers.Plan.thanks
GET   /patron/list                     controllers.Plan.list
POST  /patron/switch                   controllers.Plan.switch
POST  /patron/cancel                   controllers.Plan.cancel
POST  /patron/webhook                  controllers.Plan.webhook
POST  /patron/stripe-checkout          controllers.Plan.stripeCheckout
POST  /patron/ipn                      controllers.Plan.payPalIpn
GET   /features                        controllers.Plan.features
GET   /donate                          controllers.Main.movedPermanently(to: String = "/patron")

# Practice
GET   /practice                                   controllers.Practice.index
GET   /practice/load/:studyId/:chapterId          controllers.Practice.chapter(studyId: String, chapterId: String)
GET   /practice/config                            controllers.Practice.config
POST  /practice/config                            controllers.Practice.configSave
POST  /practice/reset                             controllers.Practice.reset
GET   /practice/:sectionId                        controllers.Practice.showSection(sectionId: String)
GET   /practice/:sectionId/:studySlug             controllers.Practice.showStudySlug(sectionId: String, studySlug: String)
GET   /practice/:sectionId/:studySlug/:studyId    controllers.Practice.show(sectionId: String, studySlug: String, studyId: String)
GET   /practice/:sectionId/:studySlug/:studyId/:chapterId controllers.Practice.showChapter(sectionId: String, studySlug: String, studyId: String, chapterId: String)
POST  /practice/complete/:chapterId/:moves        controllers.Practice.complete(chapterId: String, moves: Int)

# Streamer
GET   /streamer                        controllers.Streamer.index(page: Int ?= 1)
GET   /streamer/live                   controllers.Streamer.live
GET   /streamer/edit                   controllers.Streamer.edit
POST  /streamer/new                    controllers.Streamer.create
POST  /streamer/edit                   controllers.Streamer.editApply
POST  /streamer/approval/request       controllers.Streamer.approvalRequest
GET   /streamer/picture/edit           controllers.Streamer.picture
POST  /streamer/picture/upload         controllers.Streamer.pictureApply
POST  /streamer/picture/delete         controllers.Streamer.pictureDelete
GET   /streamer/:username              controllers.Streamer.show(username: String)
GET   /streamer/:username/redirect     controllers.Streamer.redirect(username: String)

# Round
GET   /$gameId<\w{8}>                            controllers.Round.watcher(gameId: String, color: String = "white")
GET   /$gameId<\w{8}>/$color<white|black>        controllers.Round.watcher(gameId: String, color: String)
GET   /$fullId<\w{12}>                           controllers.Round.player(fullId: String)
GET   /$gameId<\w{8}>/$color<white|black>/sides  controllers.Round.sides(gameId: String, color: String)
GET   /$gameId<\w{8}>/continue/:mode             controllers.Round.continue(gameId: String, mode: String)
GET   /$gameId<\w{8}>/note                       controllers.Round.readNote(gameId: String)
POST  /$gameId<\w{8}>/note                       controllers.Round.writeNote(gameId: String)
GET   /$gameId<\w{8}>/mini                       controllers.Round.mini(gameId: String, color: String = "white")
GET   /$gameId<\w{8}>/$color<white|black>/mini   controllers.Round.mini(gameId: String, color: String)
GET   /$fullId<\w{12}>/mini                      controllers.Round.miniFullId(fullId: String)
GET   /$gameId<\w{8}>/edit                       controllers.Editor.game(gameId: String)
GET   /$gameId<\w{8}>/$color<white|black>/analysis controllers.UserAnalysis.game(gameId: String, color: String)
POST  /$fullId<\w{12}>/forecasts                  controllers.UserAnalysis.forecasts(fullId: String)
POST  /$fullId<\w{12}>/forecasts/:uci            controllers.UserAnalysis.forecastsOnMyTurn(fullId: String, uci: String)
POST  /$fullId<\w{12}>/resign                    controllers.Round.resign(fullId: String)

GET   /embed/$gameId<\w{8}>                      controllers.Analyse.embed(gameId: String, color: String = "white")
GET   /embed/$gameId<\w{8}>/$color<white|black>  controllers.Analyse.embed(gameId: String, color: String)

POST  /$gameId<\w{8}>/delete                     controllers.Game.delete(gameId: String)

GET   /round-next/$gameId<\w{8}>                 controllers.Round.next(gameId: String)
GET   /whats-next/$fullId<\w{12}>                controllers.Round.whatsNext(fullId: String)

# Tournament
GET   /tournament                             controllers.Tournament.home
GET   /tournament/featured                    controllers.Tournament.featured
GET   /tournament/new                         controllers.Tournament.form
POST  /tournament/new                         controllers.Tournament.create
GET   /tournament/team-battle/new/:teamId     controllers.Tournament.teamBattleForm(teamId: String)
GET   /tournament/team-battle/edit/:id        controllers.Tournament.teamBattleEdit(id: String)
POST  /tournament/team-battle/edit/:id        controllers.Tournament.teamBattleUpdate(id: String)
GET   /tournament/calendar                    controllers.Tournament.calendar
GET   /tournament/history                     controllers.Tournament.history(freq: String = "unique", page: Int ?= 1)
GET   /tournament/history/:freq               controllers.Tournament.history(freq: String, page: Int ?= 1)
GET   /tournament/$id<\w{8}>                  controllers.Tournament.show(id: String)
GET   /tournament/$id<\w{8}>/standing/:page   controllers.Tournament.standing(id: String, page: Int)
GET   /tournament/$id<\w{8}>/page-of/:userId  controllers.Tournament.pageOf(id: String, userId: String)
POST  /tournament/$id<\w{8}>/join             controllers.Tournament.join(id: String)
POST  /tournament/$id<\w{8}>/withdraw         controllers.Tournament.pause(id: String)
GET   /tournament/$id<\w{8}>/player/:user     controllers.Tournament.player(id: String, user: String)
GET   /tournament/$id<\w{8}>/team/:team       controllers.Tournament.teamInfo(id: String, team: String)
POST  /tournament/$id<\w{8}>/terminate        controllers.Tournament.terminate(id: String)
GET   /tournament/$id<\w{8}>/edit             controllers.Tournament.edit(id: String)
POST  /tournament/$id<\w{8}>/edit             controllers.Tournament.update(id: String)
GET   /tournament/$id<\w{8}>/teams            controllers.Tournament.battleTeams(id: String)
GET   /tournament/help                        controllers.Tournament.help(system: Option[String] ?= None)
GET   /tournament/leaderboard                 controllers.Tournament.leaderboard
GET   /tournament/shields                     controllers.Tournament.shields
GET   /tournament/shields/:categ              controllers.Tournament.categShields(categ: String)

# Tournament CRUD
GET   /tournament/manager                     controllers.TournamentCrud.index(page: Int ?= 1)
GET   /tournament/manager/clone/$id<\w{8}>    controllers.TournamentCrud.cloneT(id: String)
GET   /tournament/manager/$id<\w{8}>          controllers.TournamentCrud.edit(id: String)
POST  /tournament/manager/$id<\w{8}>          controllers.TournamentCrud.update(id: String)
GET   /tournament/manager/new                 controllers.TournamentCrud.form
POST  /tournament/manager                     controllers.TournamentCrud.create

# Swiss
GET   /swiss                                  controllers.Swiss.home
GET   /swiss/new/:teamId                      controllers.Swiss.form(teamId: String)
POST  /swiss/new/:teamId                      controllers.Swiss.create(teamId: String)
GET   /swiss/$id<\w{8}>                       controllers.Swiss.show(id: String)
GET   /swiss/$id<\w{8}>/round/:round          controllers.Swiss.round(id: String, round: Int)
GET   /swiss/$id<\w{8}>.trf                   controllers.Swiss.exportTrf(id: String)
POST  /swiss/$id<\w{8}>/join                  controllers.Swiss.join(id: String)
POST  /swiss/$id<\w{8}>/withdraw              controllers.Swiss.withdraw(id: String)
GET   /swiss/$id<\w{8}>/edit                  controllers.Swiss.edit(id: String)
POST  /swiss/$id<\w{8}>/edit                  controllers.Swiss.update(id: String)
POST  /swiss/$id<\w{8}>/terminate             controllers.Swiss.terminate(id: String)
GET   /swiss/$id<\w{8}>/standing/:page        controllers.Swiss.standing(id: String, page: Int)
GET   /swiss/$id<\w{8}>/page-of/:user         controllers.Swiss.pageOf(id: String, user: String)
GET   /swiss/$id<\w{8}>/player/:user          controllers.Swiss.player(id: String, user: String)
POST  /swiss/$id<\w{8}>/schedule-next-round   controllers.Swiss.scheduleNextRound(id: String)

# Simul
GET   /simul                                  controllers.Simul.home
GET   /simul/new                              controllers.Simul.form
POST  /simul/new                              controllers.Simul.create
GET   /simul/reload                           controllers.Simul.homeReload
GET   /simul/$id<\w{8}>                       controllers.Simul.show(id: String)
GET   /simul/$id<\w{8}>/edit                  controllers.Simul.edit(id: String)
POST  /simul/$id<\w{8}>/edit                  controllers.Simul.update(id: String)
POST  /simul/$id<\w{8}>/host-ping             controllers.Simul.hostPing(id: String)
POST  /simul/$id<\w{8}>/accept/:user          controllers.Simul.accept(id: String, user: String)
POST  /simul/$id<\w{8}>/reject/:user          controllers.Simul.reject(id: String, user: String)
POST  /simul/$id<\w{8}>/start                 controllers.Simul.start(id: String)
POST  /simul/$id<\w{8}>/abort                 controllers.Simul.abort(id: String)
POST  /simul/$id<\w{8}>/join/:variant         controllers.Simul.join(id: String, variant: String)
POST  /simul/$id<\w{8}>/withdraw              controllers.Simul.withdraw(id: String)

# Team
GET   /team                                   controllers.Team.home(page: Int ?= 1)
GET   /team/new                               controllers.Team.form
POST  /team/new                               controllers.Team.create
GET   /team/me                                controllers.Team.mine
GET   /team/leader                            controllers.Team.leader
GET   /team/all                               controllers.Team.all(page: Int ?= 1)
GET   /team/requests                          controllers.Team.requests
GET   /team/search                            controllers.Team.search(text: String ?= "", page: Int ?= 1)
GET   /team/autocomplete                      controllers.Team.autocomplete
GET   /team/:id                               controllers.Team.show(id: String, page: Int ?= 1)
POST  /team/:id/join                          controllers.Team.join(id: String)
POST  /team/:id/quit                          controllers.Team.quit(id: String)
GET   /team/:id/request/new                   controllers.Team.requestForm(id: String)
POST  /team/:id/request/new                   controllers.Team.requestCreate(id: String)
POST  /team/:id/request/process               controllers.Team.requestProcess(id: String)
GET   /team/:id/edit                          controllers.Team.edit(id: String)
POST  /team/:id/edit                          controllers.Team.update(id: String)
GET   /team/:id/kick                          controllers.Team.kickForm(id: String)
POST  /team/:id/kick                          controllers.Team.kick(id: String)
POST  /team/:id/kick/:user                    controllers.Team.kickUser(id: String, user: String)
GET   /team/:id/leaders                       controllers.Team.leadersForm(id: String)
POST  /team/:id/leaders                       controllers.Team.leaders(id: String)
POST  /team/:id/close                         controllers.Team.close(id: String)
POST  /team/:id/disable                       controllers.Team.disable(id: String)
GET   /team/:id/tournaments                   controllers.Team.tournaments(id: String)
GET   /team/:id/pm-all                        controllers.Team.pmAll(id: String)
POST  /team/:id/pm-all                        controllers.Team.pmAllSubmit(id: String)
POST  /team/:id/subscribe                     controllers.Team.subscribe(id: String)
# Team API
GET   /api/team/all                           controllers.Team.apiAll(page: Int ?= 1)
GET   /api/team/search                        controllers.Team.apiSearch(text: String ?= "", page: Int ?= 1)
GET   /api/team/of/:username                  controllers.Team.apiTeamsOf(username: String)
GET   /api/team/:id                           controllers.Team.apiShow(id: String)
GET   /api/team/:id/users                     controllers.Team.users(id: String)
GET   /api/team/:id/arena                     controllers.Tournament.byTeam(id: String)
GET   /api/team/:id/swiss                     controllers.Swiss.byTeam(id: String)

# Analyse
POST  /$gameId<\w{8}>/request-analysis        controllers.Analyse.requestAnalysis(gameId: String)

GET   /game/export/$gameId<\w{8}>                             controllers.Game.exportOne(gameId: String)
GET   /game/export/$gameId<\w{8}>.pgn                         controllers.Game.exportOne(gameId: String)
GET   /game/export/png/$gameId<\w{8}>.png                     controllers.Export.legacyGameThumbnail(gameId: String)
GET   /game/export/gif/thumbnail/$gameId<\w{8}>.gif           controllers.Export.gameThumbnail(gameId: String)
GET   /game/export/gif/$gameId<\w{8}>.gif                     controllers.Export.gif(gameId: String, color: String = "white")
GET   /game/export/gif/$color<white|black>/$gameId<\w{8}>.gif controllers.Export.gif(gameId: String, color: String)

# Fishnet
GET   /fishnet                                controllers.Main.movedPermanently(to: String = "https://github.com/niklasf/fishnet")
POST  /fishnet/acquire                        controllers.Fishnet.acquire(slow: Boolean ?= false)
POST  /fishnet/analysis/$workId<\w{8}>        controllers.Fishnet.analysis(workId: String, slow: Boolean ?= false, stop: Boolean ?= false)
POST  /fishnet/abort/$workId<\w{8}>           controllers.Fishnet.abort(workId: String)
GET   /fishnet/key/$key<\w{8}>                controllers.Fishnet.keyExists(key: String)
GET   /fishnet/status                         controllers.Fishnet.status

# Pref
POST  /pref/:name                             controllers.Pref.set(name: String)
GET   /account/preferences/:categ             controllers.Pref.form(categ: String)
POST  /account/preferences                    controllers.Pref.formApply
POST  /account/preferences/verify-title       controllers.Pref.verifyTitle

# Setup
GET   /setup/ai                        controllers.Setup.aiForm
POST  /setup/ai                        controllers.Setup.ai
GET   /setup/friend                    controllers.Setup.friendForm(user: Option[String] ?= None)
POST  /setup/friend                    controllers.Setup.friend(user: Option[String] ?= None)
GET   /setup/hook                      controllers.Setup.hookForm
POST  /setup/hook/:sri/like/:gameId    controllers.Setup.like(sri: String, gameId: String)
POST  /setup/hook/:sri                 controllers.Setup.hook(sri: String)
GET   /setup/filter                    controllers.Setup.filterForm
GET   /setup/validate-fen              controllers.Setup.validateFen

# Challenge
GET   /challenge                       controllers.Challenge.all
GET   /challenge/$id<\w{8}>            controllers.Challenge.show(id: String, color: Option[String] ?= None)
POST  /challenge/$id<\w{8}>/accept     controllers.Challenge.accept(id: String, color: Option[String] ?= None)
POST  /challenge/$id<\w{8}>/decline    controllers.Challenge.decline(id: String)
POST  /challenge/$id<\w{8}>/cancel     controllers.Challenge.cancel(id: String)
POST  /challenge/$id<\w{8}>/to-friend  controllers.Challenge.toFriend(id: String)
POST  /challenge/rematch-of/$id<\w{8}> controllers.Challenge.rematchOf(id: String)

# Notify
GET /notify                            controllers.Notify.recent(page: Int ?= 1)

# Video
GET   /video                           controllers.Video.index
GET   /video/tags                      controllers.Video.tags
GET   /video/author/:author            controllers.Video.author(author: String)
GET   /video/:id                       controllers.Video.show(id: String)

# I18n
POST  /translation/select              controllers.I18n.select

# Authentication
GET   /login                           controllers.Auth.login
POST  /login                           controllers.Auth.authenticate
GET   /logout                          controllers.Auth.logoutGet
POST  /logout                          controllers.Auth.logout
GET   /signup                          controllers.Auth.signup
POST  /signup                          controllers.Auth.signupPost
GET   /signup/check-your-email         controllers.Auth.checkYourEmail
POST  /signup/fix-email                controllers.Auth.fixEmail
GET   /signup/confirm/:token           controllers.Auth.signupConfirmEmail(token: String)
GET   /password/reset                  controllers.Auth.passwordReset
POST  /password/reset/send             controllers.Auth.passwordResetApply
GET   /password/reset/sent/:email      controllers.Auth.passwordResetSent(email: String)
GET   /password/reset/confirm/:token   controllers.Auth.passwordResetConfirm(token: String)
POST  /password/reset/confirm/:token   controllers.Auth.passwordResetConfirmApply(token: String)
POST  /auth/set-fp/:fp/:ms             controllers.Auth.setFingerPrint(fp: String, ms: Int)
POST  /auth/token                      controllers.Auth.makeLoginToken
GET   /auth/token/:token               controllers.Auth.loginWithToken(token: String)
POST  /auth/token/:token               controllers.Auth.loginWithTokenPost(token: String, referrer: Option[String])
GET   /auth/magic-link                 controllers.Auth.magicLink
POST  /auth/magic-link/send            controllers.Auth.magicLinkApply
GET   /auth/magic-link/sent/:email     controllers.Auth.magicLinkSent(email: String)
GET   /auth/magic-link/login/:token    controllers.Auth.magicLinkLogin(token: String)

# Mod
POST  /mod/:username/alt/:v            controllers.Mod.alt(username: String, v: Boolean)
POST  /mod/:username/engine/:v         controllers.Mod.engine(username: String, v: Boolean)
POST  /mod/:username/booster/:v        controllers.Mod.booster(username: String, v: Boolean)
POST  /mod/:username/troll/:v          controllers.Mod.troll(username: String, v: Boolean)
POST  /mod/:username/delete-pms-and-chats controllers.Mod.deletePmsAndChats(username: String)
POST  /mod/:username/warn              controllers.Mod.warn(username: String, subject: String)
POST  /mod/:username/kid               controllers.Mod.kid(username: String)
POST  /mod/:username/disable-2fa       controllers.Mod.disableTwoFactor(username: String)
POST  /mod/:username/close             controllers.Mod.closeAccount(username: String)
POST  /mod/:username/reopen            controllers.Mod.reopenAccount(username: String)
POST  /mod/:username/title             controllers.Mod.setTitle(username: String)
POST  /mod/:username/inquiry           controllers.Mod.spontaneousInquiry(username: String)
GET   /mod/:username/communication     controllers.Mod.communicationPublic(username: String)
GET   /mod/:username/communication/private controllers.Mod.communicationPrivate(username: String)
POST  /mod/:username/rankban/:v        controllers.Mod.rankban(username: String, v: Boolean)
POST  /mod/:username/reportban/:v      controllers.Mod.reportban(username: String, v: Boolean)
POST  /mod/:username/impersonate       controllers.Mod.impersonate(username: String)
GET   /mod/:username/games             controllers.GameMod.index(username: String)
POST  /mod/:username/games             controllers.GameMod.post(username: String)
GET   /mod/table                       controllers.Mod.table
POST  /mod/:username/refreshUserAssess controllers.Mod.refreshUserAssess(username: String)
POST  /mod/:username/email             controllers.Mod.setEmail(username: String)
POST  /mod/:username/notify-slack      controllers.Mod.notifySlack(username: String)
GET   /mod/leaderboard                 controllers.Mod.gamify
GET   /mod/leaderboard/:period         controllers.Mod.gamifyPeriod(period: String)
GET   /mod/search                      controllers.Mod.search
GET   /mod/chat-user/:username         controllers.Mod.chatUser(username: String)
GET   /mod/:username/permissions       controllers.Mod.permissions(username: String)
POST  /mod/:username/permissions       controllers.Mod.savePermissions(username: String)
GET   /mod/public-chat                 controllers.Mod.publicChat
POST  /mod/public-chat/timeout         controllers.Mod.publicChatTimeout
GET   /mod/email-confirm               controllers.Mod.emailConfirm
GET   /mod/chat-panic                  controllers.Mod.chatPanic
POST  /mod/chat-panic                  controllers.Mod.chatPanicPost
GET   /mod/print/:fh                   controllers.Mod.print(fh: String)
POST  /mod/print/ban/:v/:fh            controllers.Mod.printBan(v: Boolean, fh: String)
GET   /mod/ip/:ip                      controllers.Mod.singleIp(ip: String)
POST  /mod/ip/ban/:v/:ip               controllers.Mod.singleIpBan(v: Boolean, ip: String)
GET   /mod/presets/:group              controllers.Mod.presets(group: String)
POST  /mod/presets/:group              controllers.Mod.presetsUpdate(group: String)
GET   /api/stream/mod                  controllers.Mod.eventStream

# Irwin
GET   /irwin                           controllers.Irwin.dashboard
POST  /irwin/report                    controllers.Irwin.saveReport
GET   /api/stream/irwin                controllers.Irwin.eventStream

# Forum
GET   /forum                           controllers.ForumCateg.index
GET   /forum/search                    controllers.ForumPost.search(text: String ?= "", page: Int ?= 1)
GET   /forum/:slug                     controllers.ForumCateg.show(slug: String, page: Int ?= 1)
GET   /forum/:categSlug/form           controllers.ForumTopic.form(categSlug: String)
POST  /forum/:categSlug/new            controllers.ForumTopic.create(categSlug: String)
GET   /forum/participants/:topicId     controllers.ForumTopic.participants(topicId: String)
GET   /forum/:categSlug/:slug          controllers.ForumTopic.show(categSlug: String, slug: String, page: Int ?= 1)
POST  /forum/:categSlug/:slug/close    controllers.ForumTopic.close(categSlug: String, slug: String)
POST  /forum/:categSlug/:slug/hide     controllers.ForumTopic.hide(categSlug: String, slug: String)
POST  /forum/:categSlug/:slug/sticky   controllers.ForumTopic.sticky(categSlug: String, slug: String)
POST  /forum/:categSlug/:slug/new      controllers.ForumPost.create(categSlug: String, slug: String, page: Int ?= 1)
POST  /forum/:categSlug/delete/:id     controllers.ForumPost.delete(categSlug: String, id: String)
POST  /forum/post/:id                  controllers.ForumPost.edit(id: String)
POST  /forum/post/:id/react/:reaction/:v controllers.ForumPost.react(id: String, reaction: String, v: Boolean)
GET   /forum/redirect/post/:id         controllers.ForumPost.redirect(id: String)

# Msg compat
POST  /inbox/new                       controllers.Msg.compatCreate
# Msg
GET   /inbox                           controllers.Msg.home
GET   /inbox/search                    controllers.Msg.search(q: String)
GET   /inbox/unread-count              controllers.Msg.unreadCount
GET   /inbox/:username                 controllers.Msg.convo(username: String, before: Option[Long] ?= None)
DELETE /inbox/:username                controllers.Msg.convoDelete(username: String)
# Msg API/compat
POST  /inbox/:username                 controllers.Msg.apiPost(username: String)
POST /inbox/:username/delete           controllers.Msg.convoDelete(username: String)

# Coach
GET   /coach                           controllers.Coach.all(page: Int ?= 1)
GET   /coach/edit                      controllers.Coach.edit
POST  /coach/edit                      controllers.Coach.editApply
GET   /coach/picture/edit              controllers.Coach.picture
POST  /coach/picture/upload            controllers.Coach.pictureApply
POST  /coach/picture/delete            controllers.Coach.pictureDelete
POST  /coach/approve-review/:id        controllers.Coach.approveReview(id: String)
POST  /coach/mod-review/:id            controllers.Coach.modReview(id: String)
GET   /coach/:username                 controllers.Coach.show(username: String)
POST  /coach/:username/review          controllers.Coach.review(username: String)
GET   /coach/:lang/:order              controllers.Coach.search(lang: String, order: String, page: Int ?= 1)

# Clas
GET   /class                           controllers.Clas.index
GET   /class/new                       controllers.Clas.form
POST  /class/become-teacher            controllers.Clas.becomeTeacher
POST  /class/new                       controllers.Clas.create
GET   /class/invitation/:id            controllers.Clas.invitation(id: String)
POST  /class/invitation/:id            controllers.Clas.invitationAccept(id: String)
GET   /class/$id<\w{8}>                controllers.Clas.show(id: String)
GET   /class/$id<\w{8}>/edit           controllers.Clas.edit(id: String)
POST  /class/$id<\w{8}>/edit           controllers.Clas.update(id: String)
GET   /class/$id<\w{8}>/news           controllers.Clas.wall(id: String)
GET   /class/$id<\w{8}>/news/edit      controllers.Clas.wallEdit(id: String)
POST  /class/$id<\w{8}>/news/edit      controllers.Clas.wallUpdate(id: String)
GET   /class/$id<\w{8}>/notify         controllers.Clas.notifyStudents(id: String)
POST  /class/$id<\w{8}>/notifyPost     controllers.Clas.notifyPost(id: String)
GET   /class/$id<\w{8}>/students       controllers.Clas.students(id: String)
POST  /class/$id<\w{8}>/archive        controllers.Clas.archive(id: String, v: Boolean)
GET   /class/$id<\w{8}>/progress/learn controllers.Clas.learn(id: String)
GET   /class/$id<\w{8}>/progress/:pt/:days controllers.Clas.progress(id: String, pt: String, days: Int)
GET   /class/$id<\w{8}>/student/add    controllers.Clas.studentForm(id: String)
POST  /class/$id<\w{8}>/student/new    controllers.Clas.studentCreate(id: String)
GET   /class/$id<\w{8}>/student/many   controllers.Clas.studentManyForm(id: String)
POST  /class/$id<\w{8}>/student/many   controllers.Clas.studentManyCreate(id: String)
POST  /class/$id<\w{8}>/student/invite controllers.Clas.studentInvite(id: String)
GET   /class/$id<\w{8}>/student/:username controllers.Clas.studentShow(id: String, username: String)
POST  /class/$id<\w{8}>/student/:username/archive controllers.Clas.studentArchive(id: String, username: String, v: Boolean)
POST  /class/$id<\w{8}>/student/:username/reset-password controllers.Clas.studentResetPassword(id: String, username: String)
GET   /class/$id<\w{8}>/student/:username/edit controllers.Clas.studentEdit(id: String, username: String)
POST  /class/$id<\w{8}>/student/:username/edit controllers.Clas.studentUpdate(id: String, username: String)
GET   /class/$id<\w{8}>/student/:username/release controllers.Clas.studentRelease(id: String, username: String)
POST  /class/$id<\w{8}>/student/:username/release controllers.Clas.studentReleasePost(id: String, username: String)
POST  /class/$id<\w{8}>/invitation/revoke controllers.Clas.invitationRevoke(id: String)

# DB image
GET   /image/:id/:hash/:name           controllers.Main.image(id: String, hash: String, name: String)

# Paste
GET   /paste                           controllers.Importer.importGame
POST  /import                          controllers.Importer.sendGame
GET   /import/master/$id<\w{8}>/:color controllers.Importer.masterGame(id: String, color: String)

# Edit
GET   /editor.json                     controllers.Editor.data
GET   /editor/*urlFen                  controllers.Editor.load(urlFen: String)
GET   /editor                          controllers.Editor.index

# Report
GET   /report                          controllers.Report.form
POST  /report                          controllers.Report.create
POST  /report/flag                     controllers.Report.flag
GET   /report/thanks                   controllers.Report.thanks(reported: String)
GET   /report/list                     controllers.Report.list
GET   /report/list/:room               controllers.Report.listWithFilter(room: String)
POST  /report/:id/inquiry              controllers.Report.inquiry(id: String)
POST  /report/:id/process              controllers.Report.process(id: String)
POST  /report/:id/xfiles               controllers.Report.xfiles(id: String)
POST  /report/:id/snooze/:dur          controllers.Report.snooze(id: String, dur: String)
GET   /report/:username/cheat-inquiry  controllers.Report.currentCheatInquiry(username: String)

# Appeal
GET   /appeal                          controllers.Appeal.home
POST  /appeal                          controllers.Appeal.post
GET   /appeal/queue                    controllers.Appeal.queue
GET   /appeal/:username                controllers.Appeal.show(username: String)
POST  /appeal/:username                controllers.Appeal.reply(username: String)
POST  /appeal/:username/mute           controllers.Appeal.mute(username: String)
POST  /appeal/:username/notify-slack   controllers.Appeal.notifySlack(username: String)

# Stats
GET    /stat/rating/distribution/:perf controllers.Stat.ratingDistribution(perf: String)

# API
GET   /api                             controllers.Api.index
POST  /api/users                       controllers.Api.usersByIds
GET   /api/user/puzzle-activity        controllers.Puzzle.activity
GET   /api/puzzle/daily                controllers.Puzzle.apiDaily
GET   /api/puzzle/activity             controllers.Puzzle.activity
GET   /api/puzzle/dashboard/:days      controllers.Puzzle.apiDashboard(days: Int)
GET   /api/user/:name/tournament/created controllers.Api.tournamentsByOwner(name: String)
GET   /api/user/:name                  controllers.Api.user(name: String)
GET   /api/user/:name/activity         controllers.Api.activity(name: String)
GET   /api/user/:name/following        controllers.Relation.apiFollowing(name: String)
GET   /api/user/:name/followers        controllers.Relation.apiFollowers(name: String)
POST  /api/user/:name/note             controllers.User.apiWriteNote(name: String)
GET   /api/user/:name/rating-history   controllers.User.ratingHistory(name: String)
GET   /api/user/:name/current-game     controllers.User.tvExport(name: String)
GET   /api/game/:id                    controllers.Api.game(id: String)
GET   /api/tournament                  controllers.Api.currentTournaments
GET   /api/tournament/:id              controllers.Api.tournament(id: String)
GET   /api/tournament/:id/games        controllers.Api.tournamentGames(id: String)
GET   /api/tournament/:id/results      controllers.Api.tournamentResults(id: String)
GET   /api/tournament/:id/teams        controllers.Api.tournamentTeams(id: String)
POST  /api/tournament                  controllers.Tournament.apiCreate
POST  /api/tournament/:id              controllers.Tournament.apiUpdate(id: String)
POST  /api/tournament/team-battle/:id  controllers.Tournament.apiTeamBattleUpdate(id: String)
POST  /api/swiss/new/:teamId           controllers.Swiss.apiCreate(teamId: String)
GET   /api/swiss/:id/games             controllers.Api.swissGames(id: String)
GET   /api/swiss/:id/results           controllers.Api.swissResults(id: String)
GET   /api/simul                       controllers.Simul.apiList
GET   /api/status                      controllers.Api.status
GET   /api/users/status                controllers.Api.usersStatus
GET   /api/crosstable/:u1/:u2          controllers.Api.crosstable(u1: String, u2: String)
POST  /api/stream/games-by-users       controllers.Api.gamesByUsersStream
GET   /api/stream/event                controllers.Api.eventStream
GET   /api/account                     controllers.Account.apiMe
GET   /api/account/playing             controllers.Account.apiNowPlaying
GET   /api/account/email               controllers.Account.apiEmail
GET   /api/account/kid                 controllers.Account.apiKid
POST  /api/account/kid                 controllers.Account.apiKidPost
GET   /api/account/preferences         controllers.Pref.apiGet
POST  /api/challenge/ai                controllers.Setup.apiAi
POST  /api/challenge/open              controllers.Challenge.openCreate
POST  /api/challenge/admin/:orig/:dest controllers.Challenge.apiCreateAdmin(orig: String, dest: String)
POST  /api/challenge/:user             controllers.Challenge.apiCreate(user: String)
POST  /api/challenge/$id<\w{8}>/accept controllers.Challenge.apiAccept(id: String)
POST  /api/challenge/$id<\w{8}>/decline controllers.Challenge.apiDecline(id: String)
POST  /api/challenge/$id<\w{8}>/cancel controllers.Challenge.apiCancel(id: String)
POST  /api/challenge/$id<\w{8}>/start-clocks  controllers.Challenge.apiStartClocks(id: String)
POST  /api/round/$id<\w{8}>/add-time/:seconds controllers.Round.apiAddTime(id: String, seconds: Int)
GET   /api/cloud-eval                  controllers.Api.cloudEval
GET   /api/broadcast                   controllers.Relay.apiIndex
POST  /api/import                      controllers.Importer.apiSendGame
GET   /api/bulk-pairing                controllers.BulkPairing.list
POST  /api/bulk-pairing                controllers.BulkPairing.create
DELETE /api/bulk-pairing/:id           controllers.BulkPairing.delete(id: String)
POST  /api/bulk-pairing/:id/start-clocks  controllers.BulkPairing.startClocks(id: String)

GET   /api/games/user/:username        controllers.Game.apiExportByUser(username: String)

# Mobile API only
GET   /api/user/:name/games            controllers.Api.userGames(name: String)

# Bot API
GET   /api/bot/game/stream/:id         controllers.PlayApi.botGameStream(id: String)
POST  /api/bot/game/:id/move/:uci      controllers.PlayApi.botMove(id: String, uci: String, offeringDraw: Option[Boolean] ?= None)
POST  /api/bot/*cmd                    controllers.PlayApi.botCommand(cmd: String)
GET   /player/bots                     controllers.PlayApi.botOnline

# Board API
GET   /api/board/game/stream/:id        controllers.PlayApi.boardGameStream(id: String)
POST  /api/board/game/:id/move/:uci     controllers.PlayApi.boardMove(id: String, uci: String, offeringDraw: Option[Boolean] ?= None)
POST  /api/board/seek                   controllers.Setup.boardApiHook
POST  /api/board/*cmd                   controllers.PlayApi.boardCommand(cmd: String)

# Account
GET   /account/passwd                  controllers.Account.passwd
POST  /account/passwd                  controllers.Account.passwdApply
GET   /account/email                   controllers.Account.email
POST  /account/email                   controllers.Account.emailApply
GET   /contact/email-confirm/help      controllers.Account.emailConfirmHelp
GET   /account/email/confirm/:token    controllers.Account.emailConfirm(token: String)
GET   /account/close                   controllers.Account.close
POST  /account/closeConfirm            controllers.Account.closeConfirm
GET   /account/profile                 controllers.Account.profile
POST  /account/profile                 controllers.Account.profileApply
GET   /account/username                controllers.Account.username
POST  /account/username                controllers.Account.usernameApply
GET   /account/kid                     controllers.Account.kid
POST  /account/kid                     controllers.Account.kidPost
GET   /account/twofactor               controllers.Account.twoFactor
POST  /account/twofactor/setup         controllers.Account.setupTwoFactor
POST  /account/twofactor/disable       controllers.Account.disableTwoFactor
GET   /account/reopen                  controllers.Account.reopen
POST  /account/reopen/send             controllers.Account.reopenApply
GET   /account/reopen/sent/:email      controllers.Account.reopenSent(email: String)
GET   /account/reopen/login/:token     controllers.Account.reopenLogin(token: String)
GET   /account/personal-data           controllers.Account.data
# App BC
GET   /account/security                controllers.Account.security
POST  /account/signout/:sessionId      controllers.Account.signout(sessionId: String)
GET   /account/info                    controllers.Account.info
GET   /account/now-playing             controllers.Account.nowPlaying

# OAuth
GET   /account/oauth/token                  controllers.OAuthToken.index
GET   /account/oauth/token/create           controllers.OAuthToken.create
POST  /account/oauth/token/create           controllers.OAuthToken.createApply
POST  /account/oauth/token/:publicId/delete controllers.OAuthToken.delete(publicId: String)
GET   /account/oauth/app                    controllers.OAuthApp.index
GET   /account/oauth/app/create             controllers.OAuthApp.create
POST  /account/oauth/app/create             controllers.OAuthApp.createApply
GET   /account/oauth/app/:id/edit           controllers.OAuthApp.edit(id: String)
POST  /account/oauth/app/:id/edit           controllers.OAuthApp.update(id: String)
POST  /account/oauth/app/:id/delete         controllers.OAuthApp.delete(id: String)
POST  /account/oauth/app/:id/revoke         controllers.OAuthApp.revoke(id: String)

# Events
GET   /event/$id<\w{8}>                controllers.Event.show(id: String)
GET   /event/manager                   controllers.Event.manager
GET   /event/manager/$id<\w{8}>        controllers.Event.edit(id: String)
POST  /event/manager/$id<\w{8}>        controllers.Event.update(id: String)
GET   /event/manager/clone/$id<\w{8}>  controllers.Event.cloneE(id: String)
GET   /event/manager/new               controllers.Event.form
POST  /event/manager                   controllers.Event.create

# Misc
GET   /captcha/$id<\w{8}>              controllers.Main.captchaCheck(id: String)
GET   /developers                      controllers.Main.webmasters
GET   /mobile                          controllers.Main.mobile
GET   /lag                             controllers.Main.lag
GET   /get-fishnet                     controllers.Main.getFishnet
GET   /costs                           controllers.Main.costs
GET   /verify-title                    controllers.Main.verifyTitle
GET   /InstantChess.com                controllers.Main.instantChess
GET   /daily-puzzle-slack              controllers.Main.dailyPuzzleSlackApp

# Dev
GET   /dev/cli                         controllers.Dev.cli
POST  /dev/cli                         controllers.Dev.cliPost
POST  /cli                             controllers.Dev.command
GET   /dev/settings                    controllers.Dev.settings
POST  /dev/settings/:id                controllers.Dev.settingsPost(id: String)

# Push
POST  /mobile/register/:platform/:deviceId controllers.Push.mobileRegister(platform: String, deviceId: String)
POST  /mobile/unregister               controllers.Push.mobileUnregister
POST  /push/subscribe                  controllers.Push.webSubscribe

# Pages
GET   /terms-of-service                controllers.Page.tos
GET   /$bookmark<privacy|thanks|about|ads|changelog> controllers.Page.menuBookmark(bookmark: String)
GET   /contact                         controllers.Main.contact
GET   /faq                             controllers.Main.faq
GET   /source                          controllers.Page.source
GET   /qa                              controllers.Main.movedPermanently(to: String = "/faq")
GET   /help                            controllers.Main.movedPermanently(to: String = "/contact")
GET   /support                         controllers.Main.movedPermanently(to: String = "/contact")
GET   /qa/:id/:slug                    controllers.Main.legacyQaQuestion(id: Int, slug: String)
GET   /how-to-cheat                    controllers.Page.loneBookmark(bookmark = "how-to-cheat")
GET   /page/:bookmark                  controllers.Page.loneBookmark(bookmark: String)

# Variants
GET   /variant                         controllers.Page.variantHome
GET   /variant/:key                    controllers.Page.variant(key)

# Help
GET   /help/contribute                 controllers.Page.help
GET   /help/master                     controllers.Page.master

# DGT
GET   /dgt                             controllers.DgtCtrl.index
GET   /dgt/play                        controllers.DgtCtrl.play
GET   /dgt/config                      controllers.DgtCtrl.config
POST  /dgt/config/token                controllers.DgtCtrl.generateToken

# Accessibility
POST  /toggle-blind-mode               controllers.Main.toggleBlindMode

GET   /prismic-preview                 controllers.Blog.preview(token: String)
POST  /jslog/$id<\w{12}>               controllers.Main.jslog(id: String)
POST  /jsmon/:event                    controllers.Main.jsmon(event: String)

GET   /swag                            controllers.Main.movedPermanently(to: String = "https://shop.spreadshirt.com/lichess-org")
GET   /yt                              controllers.Main.movedPermanently(to: String = "https://www.youtube.com/channel/UCr6RfQga70yMM9-nuzAYTsA")

GET   /assets/_$v<\w{6}>/*file         controllers.Main.devAsset(v, path="public", file)
GET   /assets/*file                    controllers.ExternalAssets.at(path="public", file)

GET   /manifest.json                   controllers.Main.manifest
GET   /robots.txt                      controllers.Main.robots

GET   /$username<\w{2,30}>             controllers.User.redirect(username: String)