From a67f0b6c85e06d5cc83fc26399df9e63d9413210 Mon Sep 17 00:00:00 2001 From: Danila Danko Date: Mon, 24 Jul 2023 00:37:57 +0300 Subject: [PATCH] add cpp --- cpp/.envrc | 1 + cpp/.gitignore | 1 + cpp/.markdownlint.jsonc | 4 + cpp/README.md | 39 +++ cpp/algorithms/ZFunction.cpp | 43 +++ .../MaxOnEdgesOnPathQueries.cpp | 314 ++++++++++++++++++ cpp/data-structures/SegmentTree/Raw.cpp | 82 +++++ cpp/data-structures/SegmentTree/Template.cpp | 105 ++++++ cpp/data-structures/SuffixArray/SA_LCP.cpp | 111 +++++++ cpp/flake.lock | 7 + cpp/flake.nix | 49 +++ flake.lock | 6 +- 12 files changed, 759 insertions(+), 3 deletions(-) create mode 100644 cpp/.envrc create mode 100644 cpp/.gitignore create mode 100644 cpp/.markdownlint.jsonc create mode 100644 cpp/README.md create mode 100644 cpp/algorithms/ZFunction.cpp create mode 100644 cpp/data-structures/HeavyLightDecomposition/MaxOnEdgesOnPathQueries.cpp create mode 100644 cpp/data-structures/SegmentTree/Raw.cpp create mode 100644 cpp/data-structures/SegmentTree/Template.cpp create mode 100644 cpp/data-structures/SuffixArray/SA_LCP.cpp create mode 100644 cpp/flake.lock create mode 100644 cpp/flake.nix diff --git a/cpp/.envrc b/cpp/.envrc new file mode 100644 index 00000000..8392d159 --- /dev/null +++ b/cpp/.envrc @@ -0,0 +1 @@ +use flake \ No newline at end of file diff --git a/cpp/.gitignore b/cpp/.gitignore new file mode 100644 index 00000000..600d2d33 --- /dev/null +++ b/cpp/.gitignore @@ -0,0 +1 @@ +.vscode \ No newline at end of file diff --git a/cpp/.markdownlint.jsonc b/cpp/.markdownlint.jsonc new file mode 100644 index 00000000..a573356f --- /dev/null +++ b/cpp/.markdownlint.jsonc @@ -0,0 +1,4 @@ +{ + "no-duplicate-header": false, + "line-length": false +} \ No newline at end of file diff --git a/cpp/README.md b/cpp/README.md new file mode 100644 index 00000000..06ad5825 --- /dev/null +++ b/cpp/README.md @@ -0,0 +1,39 @@ +# VSCodium generic + +This flake provides a devshell with `VSCodium` a `hello` executable on `PATH` and with a couple of extensions. + +## Prerequisites + +See these for additional info: + +- [codium-generic](https://github.com/deemp/flakes/tree/main/templates/codium/generic#readme) - info just about `VSCodium` and extensions. +- [nix-vscode-extensions](https://github.com/nix-community/nix-vscode-extensions) (pinned [here](https://github.com/deemp/flakes/blob/main/source-flake/vscode-extensions/flake.nix)). +- [Prerequisites](https://github.com/deemp/flakes#prerequisites). +- [Troubleshooting](https://github.com/deemp/flakes/blob/main/README/Troubleshooting.md) + +## Example + +1. Install Nix - see [how](https://github.com/deemp/flakes/blob/main/README/InstallNix.md). + +1. In a new terminal, start a devshell: + + ```console + nix flake new my-project -t github:deemp/flakes#codium-generic + cd my-project + git init && git add + nix develop + hello + ``` + +1. (Optionally) Write `settings.json` and start `VSCodium`: + + ```console + nix run .#writeSettings + nix run .#codium . + ``` + +## Configs + +- [.markdownlint.jsonc](./.markdownlint.jsonc) - for `markdownlint` from the extension `davidanson.vscode-markdownlint` +- [.envrc](./.envrc) - for [direnv](https://github.com/direnv/direnv) +- [ci.yaml](.github/workflows/ci.yaml) - a generated `GitHub Actions` workflow. See [workflows](https://github.com/deemp/flakes/tree/main/workflows). diff --git a/cpp/algorithms/ZFunction.cpp b/cpp/algorithms/ZFunction.cpp new file mode 100644 index 00000000..ee52e0b8 --- /dev/null +++ b/cpp/algorithms/ZFunction.cpp @@ -0,0 +1,43 @@ +#include +using namespace std; + +#define fou(i,a,b) for(int i = a, _i = b; i <= _i; ++i) +#define fod(i,a,b) for(int i = a, _i = b; i >= _i; --i) + +template int SIZE(T (&t)){ return t.size(); } template int SIZE(T (&t)[N]){ return N; } string to_string(char t){ return "'" + string({t}) + "'"; } string to_string(bool t){ return t ? "true" : "false"; } string to_string(const string &t, int x1=0, int x2=1e9){ string ret = ""; for(int i = min(x1,SIZE(t)), _i = min(x2,SIZE(t)-1); i <= _i; ++i){ ret += t[i]; } return '"' + ret + '"'; } string to_string(const char* t){ string ret(t); return to_string(ret); } template string to_string(const bitset &t, int x1=0, int x2=1e9){ string ret = ""; for(int i = min(x1,SIZE(t)); i <= min(x2,SIZE(t)-1); ++i){ ret += t[i] + '0'; } return to_string(ret); } template string to_string(const T (&t), int x1=0, int x2=1e9, Coords... C); template string to_string(const pair &t){ return "(" + to_string(t.first) + ", " + to_string(t.second) + ")"; } template string to_string(const T (&t), int x1, int x2, Coords... C){ string ret = "["; x1 = min(x1, SIZE(t)); auto e = begin(t); advance(e,x1); for(int i = x1, _i = min(x2,SIZE(t)-1); i <= _i; ++i){ ret += to_string(*e, C...) + (i != _i ? ", " : ""); e = next(e); } return ret + "]"; } template struct print_tuple{ string operator() (const tuple& t) { string ret = print_tuple{}(t); ret += (Index ? ", " : ""); return ret + to_string(get(t)); } }; template struct print_tuple<0, Ts...> { string operator() (const tuple& t) { return to_string(get<0>(t)); } }; template string to_string(const tuple& t) { const auto Size = tuple_size>::value; return print_tuple{}(t); } void dbgr(){;} template void dbgr(Heads H, Tails... T){ cout << to_string(H) << " | "; dbgr(T...); } void dbgs(){;} template void dbgs(Heads H, Tails... T){ cout << H << " "; dbgs(T...); } +#define dbgv(...) cout << to_string(__VA_ARGS__) << endl; +#define dbg(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgv(__VA_ARGS__); +#define dbgr(...) dbgr(__VA_ARGS__); cout << endl; +#define dbgm(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgr(__VA_ARGS__); + +#define ll long long +#define eb emplace_back + +const ll N = 1e5+3, M = 998244353; + +template +vector ZF(T &t){ + int n = t.size(); + vector z(n,0); + + for(int i = 1, l = 0, r = 0; i < n; ++i){ + if(i <= r){ + z[i] = min(z[i-l], r - i + 1); + } + while(i+z[i] < n and t[i+z[i]] == t[z[i]]) { + z[i]++; + } + if(r < i + z[i]-1){ + l = i; + r = i + z[i]-1; + } + } + return z; +} + +int main(){ + ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0); + + string s = "ksumksumkso"; + dbg(ZF(s)); +} \ No newline at end of file diff --git a/cpp/data-structures/HeavyLightDecomposition/MaxOnEdgesOnPathQueries.cpp b/cpp/data-structures/HeavyLightDecomposition/MaxOnEdgesOnPathQueries.cpp new file mode 100644 index 00000000..cc0286ed --- /dev/null +++ b/cpp/data-structures/HeavyLightDecomposition/MaxOnEdgesOnPathQueries.cpp @@ -0,0 +1,314 @@ +// There are weights of edges into parent instead of values in the nodes +// 1st node on heavy path is excluded +// Don't forget to use vertex values and include 1st node + +#include +using namespace std; + +#define fou(i, a, b) for (int i = a, _i = b; i <= _i; ++i) +#define fod(i, a, b) for (int i = a, _i = b; i >= _i; --i) + +template +int SIZE(T(&t)) +{ + return t.size(); +} +template +int SIZE(T (&t)[N]) { return N; } +string to_string(char t) { return "'" + string({t}) + "'"; } +string to_string(bool t) { return t ? "true" : "false"; } +string to_string(const string &t, int x1 = 0, int x2 = 1e9) +{ + string ret = ""; + for (int i = min(x1, SIZE(t)), _i = min(x2, SIZE(t) - 1); i <= _i; ++i) + { + ret += t[i]; + } + return '"' + ret + '"'; +} +string to_string(const char *t) +{ + string ret(t); + return to_string(ret); +} +template +string to_string(const bitset &t, int x1 = 0, int x2 = 1e9) +{ + string ret = ""; + for (int i = min(x1, SIZE(t)); i <= min(x2, SIZE(t) - 1); ++i) + { + ret += t[i] + '0'; + } + return to_string(ret); +} +template +string to_string(const T(&t), int x1 = 0, int x2 = 1e9, Coords... C); +template +string to_string(const pair &t) { return "(" + to_string(t.first) + ", " + to_string(t.second) + ")"; } +template +string to_string(const T(&t), int x1, int x2, Coords... C) +{ + string ret = "["; + x1 = min(x1, SIZE(t)); + auto e = begin(t); + advance(e, x1); + for (int i = x1, _i = min(x2, SIZE(t) - 1); i <= _i; ++i) + { + ret += to_string(*e, C...) + (i != _i ? ", " : ""); + e = next(e); + } + return ret + "]"; +} +template +struct print_tuple +{ + string operator()(const tuple &t) + { + string ret = print_tuple{}(t); + ret += (Index ? ", " : ""); + return ret + to_string(get(t)); + } +}; +template +struct print_tuple<0, Ts...> +{ + string operator()(const tuple &t) { return to_string(get<0>(t)); } +}; +template +string to_string(const tuple &t) +{ + const auto Size = tuple_size>::value; + return print_tuple{}(t); +} +void dbgr() { ; } +template +void dbgr(Heads H, Tails... T) +{ + cout << to_string(H) << " | "; + dbgr(T...); +} +void dbgs() { ; } +template +void dbgs(Heads H, Tails... T) +{ + cout << H << " "; + dbgs(T...); +} +#define dbgv(...) cout << to_string(__VA_ARGS__) << endl; +#define dbg(...) \ + cout << "[" << #__VA_ARGS__ << "]: "; \ + dbgv(__VA_ARGS__); +#define dbgr(...) \ + dbgr(__VA_ARGS__); \ + cout << endl; +#define dbgm(...) \ + cout << "[" << #__VA_ARGS__ << "]: "; \ + dbgr(__VA_ARGS__); + +#define ll long long +#define eb emplace_back + +const ll N = 103, M = 998244353; + +vector>> g(N); +vector parent, depth, heavy, head, pos, parent_weight; + +int dfs(int v = 1) +{ + int sz = 1; + int max_sub_size = 0; + depth[v] = depth[parent[v]] + 1; + + for (pair e : g[v]) + { + int child = e.first, weight = e.second; + + if (child != parent[v]) + { + parent[child] = v; + parent_weight[child] = weight; + + int sub_size = dfs(child); + + sz += sub_size; + + if (sub_size > max_sub_size) + { + max_sub_size = sub_size; + heavy[v] = child; + } + } + } + + return sz; +} + +int cur_pos = 1; +void decompose(int v = 1, int h = 1) +{ + head[v] = h; + pos[v] = cur_pos++; + + if (heavy[v] != 0) + { + decompose(heavy[v], h); + } + + for (pair e : g[v]) + { + int child = e.first, weight = e.second; + + if (child != parent[v] and child != heavy[v]) + { + decompose(child, child); + } + } +} + +vector MAX(2 * N + 3); +void build_MAX() +{ + fou(i, 1, N) + { + MAX[pos[i] + N] = parent_weight[i]; + } + fod(i, N, 1) + { + MAX[i] = max(MAX[i * 2], MAX[i * 2 + 1]); + } +} + +void update_MAX(int x, int y, int w) +{ + if (depth[x] > depth[y]) + { + swap(x, y); + } + + int p = pos[y] + N; + for (MAX[p] = w; p > 1; p >>= 1) + { + MAX[p >> 1] = max(MAX[p], MAX[p ^ 1]); + } +} + +int query_MAX(int l, int r) +{ + int ans = 0; + if (l > r) + { + return 0; + } + for (l += N, r += N + 1; l < r; l >>= 1, r >>= 1) + { + if (l & 1) + { + ans = max(ans, MAX[l++]); + } + if (r & 1) + { + ans = max(ans, MAX[--r]); + } + } + return ans; +} + +int query(int x, int y) +{ + int ret = 0; + + for (; head[x] != head[y]; y = parent[head[y]]) + { + if (depth[head[x]] > depth[head[y]]) + { + swap(x, y); + } + + int cur_heavy_path_max = query_MAX(pos[head[y]], pos[y]); + ret = max(ret, cur_heavy_path_max); + } + + if (depth[x] > depth[y]) + { + swap(x, y); + } + + // dbgm(pos[x], pos[y]); + int last_heavy_path_max = query_MAX(pos[x] + 1, pos[y]); + ret = max(ret, last_heavy_path_max); + + return ret; +} + +template +void init(T &g) +{ + int n = g.size(); + parent = vector(n); + depth = vector(n); + heavy = vector(n); + head = vector(n); + pos = vector(n); + parent_weight = vector(n); + + cur_pos = 1; + dfs(); + decompose(1, 1); + + build_MAX(); +} + +int main() +{ + ios_base::sync_with_stdio(0); + cin.tie(0); + cout.tie(0); + + // #ifdef __WIN32 + // freopen("test.txt", "r", stdin); + // #endif + + int n; + cin >> n; + + fou(i, 1, n - 1) + { + int u, v, w; + cin >> u >> v >> w; + g[u].eb(v, w); + g[v].eb(u, w); + } + + init(g); + + // dbg(parent, 1, n); + // dbg(head,1,n); + dbg(pos, 1, n); + + int arr[N]; + fou(i, 1, n) + { + arr[pos[i]] = i; + } + dbg(arr, 1, n); + dbg(parent_weight, 1, n); + // dbgm(query_MAX(1,2), query_MAX(2,3)); + + // cout << query_MAX(pos[2], pos[14]); + // dbg() + + while (true) + { + int t, x, y, w; + cin >> t >> x >> y; + if (t == 2) + { + cin >> w; + update_MAX(x, y, w); + } + else + { + cout << query(x, y) << endl; + } + } +} \ No newline at end of file diff --git a/cpp/data-structures/SegmentTree/Raw.cpp b/cpp/data-structures/SegmentTree/Raw.cpp new file mode 100644 index 00000000..7172b700 --- /dev/null +++ b/cpp/data-structures/SegmentTree/Raw.cpp @@ -0,0 +1,82 @@ +#include +using namespace std; + +#define fou(i, a, b) for (int i = a, _i = b; i <= _i; ++i) +#define fod(i, a, b) for (int i = a, _i = b; i >= _i; --i) + +#define ll long long +#define eb emplace_back + +const ll N = 1e5 + 3, M = 998244353; + +int ST[4 * N], a[N], LZ[4 * N]; + +void build(int v = 1, int tl = 1, int tr = N - 1) +{ + if (tl == tr) + { + ST[v] = a[tl]; + return; + } + + int tm = (tl + tr) / 2; + + build(v * 2, tl, tm); + build(v * 2 + 1, tm + 1, tr); + + ST[v] = ST[v * 2] + ST[v * 2 + 1]; +} + +void push(int v, int tl, int tr) +{ + if (LZ[v] and tl != tr) + { + LZ[v * 2] += LZ[v]; + LZ[v * 2 + 1] += LZ[v]; + + int tm = (tl + tr) / 2; + + ST[v * 2] += (tm - tl + 1) * LZ[v]; + ST[v * 2 + 1] += (tr - tm) * LZ[v]; + + LZ[v] = 0; + } +} + +int query(int l, int r, int v = 1, int tl = 1, int tr = N - 1) +{ + if (tr < l or tl > r or tl > tr) + { + return 0; + } + + if (l <= tl and tr <= r) + { + return ST[v]; + } + + push(v, tl, tr); + int tm = (tl + tr) / 2; + return query(l, r, v * 2, tl, tm) + + query(l, r, v * 2 + 1, tm + 1, tr); +} + +void update(int l, int r, int val, int v = 1, int tl = 1, int tr = N - 1) +{ + if (tr < l or tl > r or tl > tr) + { + return; + } + + if (l <= tl and tr <= r) + { + ST[v] += (tr - tl + 1) * val; + LZ[v] += val; + return; + } + + push(v, tl, tr); + int tm = (tl + tr) / 2; + update(l, r, val, v * 2, tl, tm); + update(l, r, val, v * 2 + 1, tm + 1, tr); +} \ No newline at end of file diff --git a/cpp/data-structures/SegmentTree/Template.cpp b/cpp/data-structures/SegmentTree/Template.cpp new file mode 100644 index 00000000..6b3da95a --- /dev/null +++ b/cpp/data-structures/SegmentTree/Template.cpp @@ -0,0 +1,105 @@ +#include + +template +class SegmentTree +{ +public: + vector tree; + vector lazy; + + SegmentTree() + { + tree.resize(4 * LEN); + lazy.resize(4 * LEN); + } + + TreeType combine(TreeType lhs, TreeType rhs) + { + /*combines two tree values*/ + return lhs + rhs; + } + + void update_vertex(int vert, LazyType val, int len) + { + /*updates node with lazy val (depending on len)*/ + if (val) + { + lazy[vert] ^= 1; + tree[vert] = len - tree[vert]; + } + } + + void build(TreeType (&arr)[LEN], int v = 1, int tl = 1, int tr = LEN - 1) + { + if (tl == tr) + { + tree[v] = arr[tl]; + return; + } + + int tm = (tl + tr) / 2; + + build(arr, v * 2, tl, tm); + build(arr, v * 2 + 1, tm + 1, tr); + + tree[v] = combine(tree[v * 2], tree[v * 2 + 1]); + } + + void push(int v, int tl, int tr) + { + if (lazy[v] and tl != tr) + { + int tm = (tr + tl) / 2; + + update_vertex(2 * v, lazy[v], tm - tl + 1); + update_vertex(2 * v + 1, lazy[v], tr - tm); + + lazy[v] = LazyType(); + } + } + + TreeType query(int l, int r, int tl = 1, int tr = LEN - 1, int v = 1) + { + if (r < tl or tr < l or tr < tl) + { + return TreeType(); + } + + if (l <= tl and tr <= r) + { + return tree[v]; + } + + push(v, tl, tr); + + int tm = (tl + tr) / 2; + + return combine(query(l, r, tl, tm, v * 2), query(l, r, tm + 1, tr, v * 2 + 1)); + } + + void update_segment(int l, int r, LazyType val, int tl = 1, int tr = LEN - 1, int v = 1) + { + if (r < tl or tr < l or tr < tl) + { + return; + } + + if (l <= tl and tr <= r) + { + update_vertex(v, val, tr - tl + 1); + return; + } + + push(v, tl, tr); + + int tm = (tl + tr) / 2; + + update_segment(l, r, val, tl, tm, v * 2); + update_segment(l, r, val, tm + 1, tr, v * 2 + 1); + + if (tl != tr) + { + tree[v] = combine(tree[v * 2], tree[v * 2 + 1]); + } + } +}; \ No newline at end of file diff --git a/cpp/data-structures/SuffixArray/SA_LCP.cpp b/cpp/data-structures/SuffixArray/SA_LCP.cpp new file mode 100644 index 00000000..edb2ca37 --- /dev/null +++ b/cpp/data-structures/SuffixArray/SA_LCP.cpp @@ -0,0 +1,111 @@ +#include +using namespace std; + +#define fou(i, a, b) for (int i = a, _i = b; i <= _i; ++i) +#define fod(i, a, b) for (int i = a, _i = b; i >= _i; --i) + +template +vector sort_cyclic_shifts(const T(&t)) +{ + int n = t.size(); + int alphabet = 300; + + vector p(n), pn(n), c(n), cn(n), from(max(n, alphabet) + 1); + + fou(i, 0, n - 1) + { + p[i] = i; + c[i] = t[i]; + from[c[i] + 1]++; + } + + fou(i, 1, from.size() - 1) + { + from[i] += from[i - 1]; + } + +#define modn(a, n) (a >= n ? a - n : a) + for (int i = 0; i < n; i = max(i * 2, 1)) + { + // suffixes in p are sorted lexicographically + // from stores starts of classes + // if multiple of same class + // the suffix with the least second part goes first in pn + // pn stores suffixes sorted by 2 parts + + fou(j, 0, n - 1) + { + int cur = modn(p[j] - i + n, n); + pn[from[c[cur]]++] = cur; + } + + int classes = 0; + from[0] = 0; + fou(j, 0, n - 1) + { + if (j and + (c[pn[j]] != c[pn[j - 1]] or + c[modn(pn[j] + i, n)] != c[modn(pn[j - 1] + i, n)])) + { + ++classes; + from[classes] = j; + } + + cn[pn[j]] = classes; + } + + swap(p, pn); + swap(c, cn); + } +#undef modn + + return p; +} + +template +vector sort_suffixes(T(&t)) +{ + t.push_back(0); + vector sa = sort_cyclic_shifts(t); + t.pop_back(); + sa.erase(begin(sa)); + return sa; +} + +vector kasai(string &s, vector &sa) +{ + int n = s.size(), k = 0; + vector lcp(n, 0); + vector c(n, 0); + + for (int i = 0; i < n; i++) + c[sa[i]] = i; + + for (int i = 0; i < n; i++, k ? k-- : 0) + { + if (c[i] == n - 1) + { + k = 0; + continue; + } + int j = sa[c[i] + 1]; + while (i + k < n && j + k < n && s[i + k] == s[j + k]) + k++; + lcp[c[i]] = k; + } + return lcp; +} + +int main() +{ + string s; + cin >> s; + + vector sa = sort_suffixes(s); + for (int i : sa) + { + cout << s.substr(i) << "\n"; + } + + vector lcp = kasai(s, sa); +} \ No newline at end of file diff --git a/cpp/flake.lock b/cpp/flake.lock new file mode 100644 index 00000000..5999137c --- /dev/null +++ b/cpp/flake.lock @@ -0,0 +1,7 @@ +{ + "nodes": { + "root": {} + }, + "root": "root", + "version": 7 +} diff --git a/cpp/flake.nix b/cpp/flake.nix new file mode 100644 index 00000000..d53217bf --- /dev/null +++ b/cpp/flake.nix @@ -0,0 +1,49 @@ +{ + outputs = inputs: + let flakes = (import ../.).outputs.inputs.flakes; in + flakes.makeFlake { + inputs = { inherit (flakes.all) nixpkgs codium devshell; }; + perSystem = { inputs, system }: + let + pkgs = inputs.nixpkgs.legacyPackages.${system}; + inherit (inputs.codium.lib.${system}) mkCodium writeSettingsJSON extensions extensionsCommon settingsCommonNix; + inherit (inputs.devshell.lib.${system}) mkCommands mkRunCommands mkShell; + + packages = { + # --- IDE --- + + # We compose `VSCodium` with extensions + codium = mkCodium { extensions = extensionsCommon // { inherit (extensions) cpp; }; }; + + # a script to write `.vscode/settings.json` + writeSettings = writeSettingsJSON settingsCommonNix; + }; + + tools = [ pkgs.clang ]; + + devShells.default = mkShell { + packages = tools; + bash.extra = "hello"; + commands = + mkCommands "tools" tools + ++ mkRunCommands "ide" { "codium ." = packages.codium; inherit (packages) writeSettings; }; + }; + in + { + inherit packages devShells; + }; + }; + + nixConfig = { + extra-trusted-substituters = [ + "https://nix-community.cachix.org" + "https://cache.iog.io" + "https://deemp.cachix.org" + ]; + extra-trusted-public-keys = [ + "nix-community.cachix.org-1:mB9FSh9qf2dCimDSUo8Zy7bkq5CX+/rkCWyvRCYg3Fs=" + "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" + "deemp.cachix.org-1:9shDxyR2ANqEPQEEYDL/xIOnoPwxHot21L5fiZnFL18=" + ]; + }; +} diff --git a/flake.lock b/flake.lock index 64955efe..36331e6f 100644 --- a/flake.lock +++ b/flake.lock @@ -2,11 +2,11 @@ "nodes": { "flakes": { "locked": { - "lastModified": 1690119111, - "narHash": "sha256-wh9XI5um0Bv13WHX/Hhf3wEaXJKonMM+eEOWWTcwYpM=", + "lastModified": 1690146036, + "narHash": "sha256-KOdUqhyvHO/F5bBgmKwUd+KogFcnL3vgXUx6RtFsUsE=", "owner": "deemp", "repo": "flakes", - "rev": "695eb04c975380959b087a21baeb849616c17213", + "rev": "c96a6775b52b17f1dd1fee61719fcb30e9f562cb", "type": "github" }, "original": {