vim.cmd("set expandtab") vim.cmd("set tabstop=4") vim.cmd("set softtabstop=4") vim.cmd("set shiftwidth=4") vim.cmd("set splitright") vim.cmd("set splitbelow") vim.cmd("set selectmode=key") vim.cmd("set keymodel=startsel") vim.cmd("set number") vim.cmd("set cursorline") vim.cmd("set termguicolors") vim.cmd("set clipboard+=unnamedplus") vim.cmd("set updatetime=700") vim.cmd("set whichwrap+=<,>,[,]") vim.cmd("set relativenumber") vim.cmd("set signcolumn=yes") -- vim.cmd("set iskeyword-=_") vim.cmd("set list") vim.cmd("set noequalalways") vim.opt.guicursor = { "i:ver25-blinkon500-blinkoff500,a:ver25-iCursor", } vim.opt.listchars = { eol = "↵", tab = "→ ", trail = "␣", precedes = "«", extends = "»" } vim.diagnostic.config({ update_in_insert = true, float = { border = "single" }, }) vim.cmd([[au CursorHold * lua vim.diagnostic.open_float(0,{scope = "cursor"})]]) vim.g.mapleader = " " local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim" if not vim.loop.fs_stat(lazypath) then vim.fn.system({ "git", "clone", "--filter=blob:none", "https://github.com/folke/lazy.nvim.git", "--branch=stable", -- latest stable release lazypath, }) end vim.opt.rtp:prepend(lazypath) local plugins = { {"loctvl842/monokai-pro.nvim", name="monokai", priority=1000}, { 'nvim-telescope/telescope.nvim', tag = '0.1.5', dependencies = { 'nvim-lua/plenary.nvim' } }, {"nvim-treesitter/nvim-treesitter", build = ":TSUpdate"}, { "nvim-neo-tree/neo-tree.nvim", branch = "v3.x", dependencies = { "nvim-lua/plenary.nvim", "nvim-tree/nvim-web-devicons", -- not strictly required, but recommended "MunifTanjim/nui.nvim", "3rd/image.nvim" } }, { 'neovim/nvim-lspconfig', dependencies = { -- Automatically install LSPs to stdpath for neovim {'williamboman/mason.nvim', config = true}, 'williamboman/mason-lspconfig.nvim', -- Useful status updates for LSP -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})` { 'j-hui/fidget.nvim', tag = 'legacy', opts = {} }, -- Additional lua configuration, makes nvim stuff amazing! 'folke/neodev.nvim', }, }, { "hrsh7th/nvim-cmp", dependencies = { "hrsh7th/cmp-nvim-lsp", "hrsh7th/cmp-buffer", "hrsh7th/cmp-path", "hrsh7th/cmp-cmdline", "L3MON4D3/LuaSnip", "saadparwaiz1/cmp_luasnip", "hrsh7th/cmp-emoji", }, }, { 'romgrk/barbar.nvim', dependencies = { 'lewis6991/gitsigns.nvim', -- OPTIONAL: for git status 'nvim-tree/nvim-web-devicons', -- OPTIONAL: for file icons }, init = function() vim.g.barbar_auto_setup = false end, opts = { -- lazy.nvim will automatically call setup for you. put your options here, anything missing will use the default: -- animation = true, -- insert_at_start = true, -- …etc. }, version = '^1.0.0', -- optional: only update when a new 1.x version is released }, { 'lvimuser/lsp-inlayhints.nvim' }, { "ray-x/lsp_signature.nvim", event = "VeryLazy", opts = {}, config = function(_, opts) require'lsp_signature'.setup(opts) end }, { "folke/which-key.nvim", event = "VeryLazy", init = function() vim.o.timeout = true vim.o.timeoutlen = 300 end, opts = { -- your configuration comes here -- or leave it empty to use the default settings -- refer to the configuration section below } }, { 'jdhao/better-escape.vim' }, { 'Pocco81/auto-save.nvim', opts = { enabled = true, } }, { "windwp/nvim-autopairs", event = "InsertEnter", opts = {} }, { "dhruvasagar/vim-prosession", dependencies = { "tpope/vim-obsession", }, }, { "arsham/arshamiser.nvim", dependencies = { "arsham/arshlib.nvim", "famiu/feline.nvim", "rebelot/heirline.nvim", "kyazdani42/nvim-web-devicons", }, config = function() -- ignore any parts you don't want to use vim.cmd.colorscheme("arshamiser_light") require("arshamiser.feliniser") -- or: -- require("arshamiser.heirliniser") _G.custom_foldtext = require("arshamiser.folding").foldtext vim.opt.foldtext = "v:lua.custom_foldtext()" -- if you want to draw a tabline: vim.api.nvim_set_option("tabline", [[%{%v:lua.require("arshamiser.tabline").draw()%}]]) end, }, { 'numToStr/Comment.nvim', opts = { -- add any options here }, lazy = false, }, { 'onsails/lspkind.nvim' }, { 'MunifTanjim/eslint.nvim', dependencies = { 'jose-elias-alvarez/null-ls.nvim' } }, { 'MunifTanjim/prettier.nvim', dependencies = { 'jose-elias-alvarez/null-ls.nvim' } }, { 'simrat39/symbols-outline.nvim' }, { "folke/todo-comments.nvim", dependencies = { "nvim-lua/plenary.nvim" }, opts = { -- your configuration comes here -- or leave it empty to use the default settings -- refer to the configuration section below } }, { 'nvim-treesitter/nvim-treesitter-context' }, { 'mg979/vim-visual-multi' }, { 'sindrets/diffview.nvim' }, { 'sitiom/nvim-numbertoggle' }, { 'mawkler/modicator.nvim' }, { "ecthelionvi/NeoColumn.nvim", opts = {} }, { "utilyre/barbecue.nvim", name = "barbecue", version = "*", dependencies = { "SmiteshP/nvim-navic", "nvim-tree/nvim-web-devicons", -- optional dependency }, opts = { -- configurations go here }, }, {'akinsho/git-conflict.nvim', version = "*", config = true }, { 'mrjones2014/legendary.nvim', -- since legendary.nvim handles all your keymaps/commands, -- its recommended to load legendary.nvim before other plugins priority = 10000, lazy = false, -- sqlite is only needed if you want to use frecency sorting -- dependencies = { 'kkharji/sqlite.lua' } }, { 'stevearc/dressing.nvim', opts = {}, }, { "folke/twilight.nvim", opts = { -- your configuration comes here -- or leave it empty to use the default settings -- refer to the configuration section below } }, { "lukas-reineke/indent-blankline.nvim", main = "ibl", opts = {} }, { 'arielherself/vim-cursorword' }, { 'm-demare/hlargs.nvim' }, { 'chentoast/marks.nvim' }, { "sontungexpt/sttusline", dependencies = { "nvim-tree/nvim-web-devicons", }, event = { "BufEnter" }, config = function(_, opts) require("sttusline").setup { -- statusline_color = "#000000", statusline_color = "StatusLine", -- | 1 | 2 | 3 -- recommended: 3 laststatus = 3, disabled = { filetypes = { -- "NvimTree", -- "lazy", }, buftypes = { -- "terminal", }, }, components = { "mode", "filename", "git-branch", "git-diff", "%=", "diagnostics", "lsps-formatters", "copilot", "indent", "encoding", "pos-cursor", "pos-cursor-progress", }, } end, }, { 'gaborvecsei/usage-tracker.nvim' }, { 'wakatime/vim-wakatime', lazy = false }, { 'smoka7/hop.nvim', version = "*", opts = {}, }, { "kylechui/nvim-surround", version = "*", -- Use for stability; omit to use `main` branch for the latest features event = "VeryLazy", config = function() require("nvim-surround").setup({ -- Configuration here, or leave empty to use defaults }) end }, { "folke/trouble.nvim", dependencies = { "nvim-tree/nvim-web-devicons" }, opts = { -- your configuration comes here -- or leave it empty to use the default settings -- refer to the configuration section below }, }, { "kawre/leetcode.nvim", build = ":TSUpdate html", dependencies = { "nvim-telescope/telescope.nvim", "nvim-lua/plenary.nvim", -- required by telescope "MunifTanjim/nui.nvim", -- optional "nvim-treesitter/nvim-treesitter", "rcarriga/nvim-notify", "nvim-tree/nvim-web-devicons", "3rd/image.nvim", }, opts = { ---@type string arg = "leetcode.nvim", ---@type lc.lang lang = "cpp", cn = { -- leetcode.cn enabled = true, ---@type boolean translator = true, ---@type boolean translate_problems = true, ---@type boolean }, ---@type lc.storage storage = { home = vim.fn.stdpath("data") .. "/.leetcode", cache = vim.fn.stdpath("cache") .. "/.leetcode", }, ---@type table plugins = { non_standalone = false, }, ---@type boolean logging = true, injector = { ['cpp'] = { before = [[ ]], }, }, ---@type table cache = { update_interval = 60 * 60 * 24 * 7, ---@type integer 7 days }, console = { open_on_runcode = true, ---@type boolean dir = "row", ---@type lc.direction size = { ---@type lc.size width = "90%", height = "75%", }, result = { size = "60%", ---@type lc.size }, testcase = { virt_text = true, ---@type boolean size = "40%", ---@type lc.size }, }, description = { position = "left", ---@type lc.position width = "35%", ---@type lc.size show_stats = true, ---@type boolean }, hooks = { ---@type fun()[] ["enter"] = {}, ---@type fun(question: lc.ui.Question)[] ["question_enter"] = {}, ---@type fun()[] ["leave"] = {}, }, keys = { toggle = { "q" }, ---@type string|string[] confirm = { "" }, ---@type string|string[] reset_testcases = "r", ---@type string use_testcase = "U", ---@type string focus_testcases = "H", ---@type string focus_result = "L", ---@type string }, ---@type lc.highlights theme = {}, ---@type boolean image_support = false, } }, { 'Civitasv/cmake-tools.nvim' } } local opts = { } require("lazy").setup(plugins, opts) require("monokai-pro").setup({ transparent_background = true, terminal_colors = true, devicons = true, -- highlight the icons of `nvim-web-devicons` styles = { comment = { italic = true }, keyword = { italic = true }, -- any other keyword type = { italic = false }, -- (preferred) int, long, char, etc storageclass = { italic = true }, -- static, register, volatile, etc structure = { italic = true }, -- struct, union, enum, etc parameter = { italic = true }, -- parameter pass in function annotation = { italic = true }, tag_attribute = { italic = true }, -- attribute of tag in reactjs }, filter = "spectrum", -- classic | octagon | pro | machine | ristretto | spectrum -- Enable this will disable filter option day_night = { enable = false, -- turn off by default day_filter = "pro", -- classic | octagon | pro | machine | ristretto | spectrum night_filter = "spectrum", -- classic | octagon | pro | machine | ristretto | spectrum }, inc_search = "background", -- underline | background background_clear = { -- "float_win", "toggleterm", -- "telescope", -- "which-key", "renamer", "notify", -- "nvim-tree", -- "neo-tree", -- "bufferline", -- better used if background of `neo-tree` or `nvim-tree` is cleared },-- "float_win", "toggleterm", "telescope", "which-key", "renamer", "neo-tree", "nvim-tree", "bufferline" plugins = { bufferline = { underline_selected = false, underline_visible = false, }, indent_blankline = { context_highlight = "default", -- default | pro context_start_underline = false, }, }, }) vim.cmd([[colorscheme monokai-pro]]) local builtin = require("telescope.builtin") vim.keymap.set('n', 'p', builtin.find_files, {}) vim.keymap.set('n', 'g', builtin.live_grep, {}) local config = require("nvim-treesitter.configs") config.setup({ ensure_installed = {"lua", "cpp", "rust", "javascript", "python", "typescript", "html", "css", "scss"}, auto_install = true, highlight = { enable = true}, indent = { enable = true}, }) vim.keymap.set('n', 'f', 'Neotree . toggle left', {}) -- import nvim-cmp plugin safely local cmp_status, cmp = pcall(require, "cmp") if not cmp_status then return end -- import luasnip plugin safely local luasnip_status, luasnip = pcall(require, "luasnip") if not luasnip_status then return end vim.opt.completeopt = "menu,menuone,noselect" cmp.setup({ snippet = { expand = function(args) luasnip.lsp_expand(args.body) end, }, mapping = cmp.mapping.preset.insert({ [""] = cmp.mapping.select_prev_item(), -- previous suggestion [""] = cmp.mapping.select_next_item(), -- next suggestion [""] = cmp.mapping.scroll_docs(-4), [""] = cmp.mapping.scroll_docs(4), [""] = cmp.mapping.complete(), -- show completion suggestions [""] = cmp.mapping.abort(), -- close completion window [""] = cmp.mapping.confirm({ select = true }), }), -- sources for autocompletion sources = cmp.config.sources({ { name = "nvim_lsp" }, -- LSP { name = "luasnip" }, -- snippets { name = "buffer" }, -- text within the current buffer { name = "path" }, -- file system paths }), }) -- Setup language servers. local lspconfig = require('lspconfig') local capabilities = require('cmp_nvim_lsp').default_capabilities() lspconfig.svls.setup { capabilities = capabilities } lspconfig.clangd.setup { capabilities = capabilities, cmd = { "clangd", "--header-insertion=never" } } lspconfig.pyright.setup { capabilities = capabilities } lspconfig.tsserver.setup { capabilities = capabilities } lspconfig.rust_analyzer.setup { capabilities = capabilities, -- Server-specific settings. See `:help lspconfig-setup` settings = { ['rust-analyzer'] = {}, }, } -- Global mappings. -- See `:help vim.diagnostic.*` for documentation on any of the below functions vim.keymap.set('n', 'e', vim.diagnostic.open_float) vim.keymap.set('n', '[d', vim.diagnostic.goto_prev) vim.keymap.set('n', ']d', vim.diagnostic.goto_next) vim.keymap.set('n', 'q', vim.diagnostic.setloclist) -- Use LspAttach autocommand to only map the following keys -- after the language server attaches to the current buffer vim.api.nvim_create_autocmd('LspAttach', { group = vim.api.nvim_create_augroup('UserLspConfig', {}), callback = function(ev) -- Enable completion triggered by vim.bo[ev.buf].omnifunc = 'v:lua.vim.lsp.omnifunc' -- Buffer local mappings. -- See `:help vim.lsp.*` for documentation on any of the below functions local opts = { buffer = ev.buf } vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, opts) vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts) vim.keymap.set('n', 'K', vim.lsp.buf.hover, opts) vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, opts) vim.keymap.set('n', '', vim.lsp.buf.signature_help, opts) vim.keymap.set('n', 'wa', vim.lsp.buf.add_workspace_folder, opts) vim.keymap.set('n', 'wr', vim.lsp.buf.remove_workspace_folder, opts) vim.keymap.set('n', 'wl', function() print(vim.inspect(vim.lsp.buf.list_workspace_folders())) end, opts) vim.keymap.set('n', 'D', vim.lsp.buf.type_definition, opts) vim.keymap.set('n', 'rn', vim.lsp.buf.rename, opts) vim.keymap.set({ 'n', 'v' }, 'ca', vim.lsp.buf.code_action, opts) vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts) end, }) require("lsp-inlayhints").setup() vim.api.nvim_create_augroup("LspAttach_inlayhints", {}) vim.api.nvim_create_autocmd("LspAttach", { group = "LspAttach_inlayhints", callback = function(args) if not (args.data and args.data.client_id) then return end local bufnr = args.buf local client = vim.lsp.get_client_by_id(args.data.client_id) require("lsp-inlayhints").on_attach(client, bufnr) end, }) require("lsp_signature").setup({}) vim.keymap.set({'i', 'n', 'v', 'x'}, '', '', {noremap=true}) vim.keymap.set({'i', 'n', 'v', 'x'}, '', '', {noremap=true}) vim.keymap.set('i', '', 'PA') vim.keymap.set('i', '', 'ddi') vim.keymap.set('i', '', '^i') vim.keymap.set('i', '', 'ggVG') vim.keymap.set('n', '', 'ggVG') vim.keymap.set('n', '`', 'splitterminali') vim.keymap.set('n', 'l', '40vs std.in') vim.keymap.set('n', 'n', 'tabnew') vim.keymap.set('t', '', '', {noremap=true}) vim.keymap.set('n', 's', 'SymbolsOutline') vim.keymap.set("v", "", ">gv") vim.keymap.set("v", "", "t', 'TodoTelescope') vim.keymap.set('v', "", "dpV`]") vim.keymap.set('v', "", "dkPV`]") vim.keymap.set('n', '', 'Legendary', {noremap=true}) vim.keymap.set({'n', 'v', 'x'}, 'h', 'HopWord') vim.keymap.set('n', 'dd', 'TroubleToggle document_diagnostics'); vim.keymap.set('n', 'dw', 'TroubleToggle workspace_diagnostics'); vim.keymap.set('n', 'dq', 'TroubleToggle quickfix'); vim.keymap.set('n', 'w', 'TroubleToggle lsp_definitions'); vim.keymap.set('n', 'r', 'TroubleToggle lsp_references'); require("nvim-treesitter.configs").setup { incremental_selection = { enable = true, keymaps = { node_incremental = "v", node_decremental = "V", }, }, } vim.api.nvim_create_autocmd("FileType", { pattern = "cpp", callback = function() vim.api.nvim_buf_set_keymap(0, 'n', "b", "10spte g++ -std=c++17 -Wall -Ofast -g -fsanitize=address -fsanitize=undefined % && ./a.out < std.ini", { silent = true, noremap = true }) end, }) vim.api.nvim_create_user_command('Backup', '!git add . && git commit -m "backup" && git push', {}) require('Comment').setup() local str = require("cmp.utils.str") local types = require("cmp.types") local lspkind = require('lspkind') cmp.setup { formatting = { format = lspkind.cmp_format({ mode = 'symbol', -- show only symbol annotations maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters) -- can also be a function to dynamically calculate max width such as -- maxwidth = function() return math.floor(0.45 * vim.o.columns) end, ellipsis_char = '...', -- when popup menu exceed maxwidth, the truncated part would show ellipsis_char instead (must define maxwidth first) show_labelDetails = true, -- show labelDetails in menu. Disabled by default -- The function below will be called before any actual modifications from lspkind -- so that you can provide more controls on popup customization. (See [#30](https://github.com/onsails/lspkind-nvim/pull/30)) before = function (entry, vim_item) local word = entry:get_insert_text() if entry.completion_item.insertTextFormat == types.lsp.InsertTextFormat.Snippet then word = vim.lsp.util.parse_snippet(word) end word = str.oneline(word) if entry.completion_item.insertTextFormat == types.lsp.InsertTextFormat.Snippet and string.sub(vim_item.abbr, -1, -1) == "~" then word = word .. "~" end vim_item.abbr = word return vim_item end }) } } local null_ls = require("null-ls") local eslint = require("eslint") local group = vim.api.nvim_create_augroup("lsp_format_on_save", { clear = false }) local event = "BufWritePre" -- or "BufWritePost" local async = event == "BufWritePost" null_ls.setup() eslint.setup({ bin = 'eslint', -- or `eslint_d` code_actions = { enable = true, apply_on_save = { enable = true, types = { "directive", "problem", "suggestion", "layout" }, }, disable_rule_comment = { enable = true, location = "separate_line", -- or `same_line` }, }, diagnostics = { enable = true, report_unused_disable_directives = false, run_on = "type", -- or `save` }, }) local prettier = require("prettier") prettier.setup({ bin = 'prettier', -- or `'prettierd'` (v0.23.3+) filetypes = { "css", "graphql", "html", "javascript", "javascriptreact", "json", "less", "markdown", "scss", "typescript", "typescriptreact", "yaml", "vue", }, }) require("symbols-outline").setup() require("todo-comments").setup() lspconfig.volar.setup{ filetypes = {'typescript', 'javascript', 'javascriptreact', 'typescriptreact', 'vue', 'json'} } local map = vim.api.nvim_set_keymap local opts = { noremap = true, silent = true } -- Move to previous/next map('n', '', 'BufferPrevious', opts) map('n', '', 'BufferNext', opts) -- Re-order to previous/next map('n', '', 'BufferMovePrevious', opts) map('n', '>', 'BufferMoveNext', opts) map('n', '', 'BufferPin', opts); map('n', '', 'BufferClose', opts); require('diffview').setup() require('modicator').setup() require("barbecue.ui").toggle(true) local highlight = { "RainbowRed", "RainbowYellow", "RainbowBlue", "RainbowOrange", "RainbowGreen", "RainbowViolet", "RainbowCyan", } local hooks = require "ibl.hooks" -- create the highlight groups in the highlight setup hook, so they are reset -- every time the colorscheme changes hooks.register(hooks.type.HIGHLIGHT_SETUP, function() vim.api.nvim_set_hl(0, "RainbowRed", { fg = "#E06C75" }) vim.api.nvim_set_hl(0, "RainbowYellow", { fg = "#E5C07B" }) vim.api.nvim_set_hl(0, "RainbowBlue", { fg = "#61AFEF" }) vim.api.nvim_set_hl(0, "RainbowOrange", { fg = "#D19A66" }) vim.api.nvim_set_hl(0, "RainbowGreen", { fg = "#98C379" }) vim.api.nvim_set_hl(0, "RainbowViolet", { fg = "#C678DD" }) vim.api.nvim_set_hl(0, "RainbowCyan", { fg = "#56B6C2" }) end) require("ibl").setup { indent = { highlight = highlight, char = "▏" }, scope = { enabled = true }, } require('hlargs').setup() require('marks').setup() require('usage-tracker').setup({ keep_eventlog_days = 31, cleanup_freq_days = 7, event_wait_period_in_sec = 5, inactivity_threshold_in_min = 5, inactivity_check_freq_in_sec = 5, verbose = 0, telemetry_endpoint = "" -- you'll need to start the restapi for this feature }) local function lines(str) local result = {} for line in str:gmatch '[^\n]+' do table.insert(result, line) end return result end local ls = require('luasnip') local snip = ls.snippet local text = ls.text_node local include_snippet = [[ #pragma GCC optimize("Ofast") ///////////////////////////////////////////////////////// /** * Useful Macros * by subcrip * (requires C++17) */ #include using namespace std; /* macro helpers */ #define __NARGS(...) std::tuple_size::value #define __DECOMPOSE_S(a, x) auto x = a; #define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; constexpr void __() {} #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() #define __as_typeof(container) decltype(container)::value_type /* type aliases */ using ll = int64_t; using ull = uint64_t; using pii = pair; using pil = pair; using pli = pair; using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; constexpr ll MDL = 1e9 + 7; constexpr ll PRIME = 998'244'353; constexpr ll MDL1 = 8784491; constexpr ll MDL2 = PRIME; /* random */ mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); /* bit-wise operations */ #define lowbit(x) ((x) & -(x)) #define popcount(x) (__builtin_popcountll(ll(x))) #define parity(x) (__builtin_parityll(ll(x))) #define msp(x) (63LL - __builtin_clzll(ll(x))) #define lsp(x) (__builtin_ctzll(ll(x))) /* arithmetic operations */ #define mod(x, y) ((((x) % (y)) + (y)) % (y)) /* fast pairs */ #define upair ull #define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) #define u1(p) ((p) >> 32) #define u2(p) ((p) & ((1ULL << 32) - 1)) #define ult std::less #define ugt std::greater #define ipair ull #define imake(x, y) (umake(x, y)) #define i1(p) (int(u1(ll(p)))) #define i2(p) (ll(u2(p) << 32) >> 32) struct ilt { bool operator()(const ipair& a, const ipair& b) const { if (i1(a) == i1(b)) return i2(a) < i2(b); else return i1(a) < i1(b); } }; struct igt { bool operator()(const ipair& a, const ipair& b) const { if (i1(a) == i1(b)) return i2(a) > i2(b); else return i1(a) > i1(b); } }; /* conditions */ #define loop while (1) #define if_or(var, val) if (!(var == val)) var = val; else #define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) #define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) /* hash */ struct safe_hash { // https://codeforces.com/blog/entry/62393 static uint64_t splitmix64(uint64_t x) { // http://xorshift.di.unimi.it/splitmix64.c x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >> 31); } size_t operator()(uint64_t x) const { static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); return splitmix64(x + FIXED_RANDOM); } }; struct pair_hash { template size_t operator()(const pair& a) const { auto hash1 = safe_hash()(a.first); auto hash2 = safe_hash()(a.second); if (hash1 != hash2) { return hash1 ^ hash2; } return hash1; } }; /* build data structures */ #define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) #define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) #define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) #define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) #define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) #define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) #define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) template pair> discretize(Iterator __first, Iterator __last) { set st(__first, __last); size_t N = 0; map mp; for (auto&& x : st) mp[x] = ++N; return {N, mp}; } template pair> unordered_discretize(Iterator __first, Iterator __last) { set st(__first, __last); size_t N = 0; unordered_map mp; for (auto&& x : st) mp[x] = ++N; return {N, mp}; } /* io */ #define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) template void __read(T& x) { cin >> x; } template void __read(T& x, U&... args) { cin >> x; __read(args...); } #define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) #define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) #define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) #define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) #define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) template ostream& operator<<(ostream& out, const pair& p) { out << "{" << p.first << ", " << p.second << "}"; return out; } template void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { using swallow = int[]; // guaranties left to right order (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; } template decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { os << "{"; print_tuple_impl(os, t, std::index_sequence_for{}); return os << "}"; } template ostream& operator<<(ostream& out, const vector& vec) { for (auto&& i : vec) out << i << ' '; return out; } /* pops */ #define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) #define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* math */ constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } void __exgcd(ll a, ll b, ll& x, ll& y) { if (b == 0) { x = 1, y = 0; return; } __exgcd(b, a % b, y, x); y -= a / b * x; } ll inverse(ll a, ll b) { ll x, y; __exgcd(a, b, x, y); return mod(x, b); } /* string algorithms */ vector calc_next(string t) { // pi function of t int n = (int)t.length(); vector pi(n); for (int i = 1; i < n; i++) { int j = pi[i - 1]; while (j > 0 && t[i] != t[j]) j = pi[j - 1]; if (t[i] == t[j]) j++; pi[i] = j; } return pi; } vector calc_z(string t) { // z function of t int m = t.length(); vector z; z.push_back(m); pair prev = {1, -1}; for (int i = 1; i < m; ++i) { if (z[i - prev.first] + i <= prev.second) { z.push_back(z[i - prev.first]); } else { int j = max(i, prev.second + 1); while (j < m && t[j] == t[j - i]) ++j; z.push_back(j - i); prev = {i, j - 1}; } } return z; } vector kmp(string s, string t) { // find all t in s string cur = t + '#' + s; int sz1 = s.size(), sz2 = t.size(); vector v; vector lps = calc_next(cur); for (int i = sz2 + 1; i <= sz1 + sz2; i++) { if (lps[i] == sz2) v.push_back(i - 2 * sz2); } return v; } int period(string s) { // find the length of shortest recurring period int n = s.length(); auto z = calc_z(s); for (int i = 1; i <= n / 2; ++i) { if (n % i == 0 && z[i] == n - i) { return i; } } return n; } ///////////////////////////////////////////////////////// ]] ls.add_snippets(nil, { cpp = { snip({ trig = 'include', namr = 'Useful Macros', dscr = 'Useful Macros', },{ text(lines(include_snippet)) }) } })