{"id":15690756,"url":"https://github.com/itzmeanjan/kodr","last_synced_at":"2025-09-09T08:44:11.256Z","repository":{"id":47759312,"uuid":"389653968","full_name":"itzmeanjan/kodr","owner":"itzmeanjan","description":"Random Linear Network Coding","archived":false,"fork":false,"pushed_at":"2021-08-20T07:30:46.000Z","size":2285,"stargazers_count":13,"open_issues_count":2,"forks_count":5,"subscribers_count":5,"default_branch":"main","last_synced_at":"2025-05-08T00:06:59.040Z","etag":null,"topics":["coding","decoding","encoding","erasure-coding","networkcoding","networking","randomlinearnetworkcoding","recoding","rlnc"],"latest_commit_sha":null,"homepage":"https://pkg.go.dev/github.com/itzmeanjan/kodr","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"cc0-1.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/itzmeanjan.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2021-07-26T14:04:48.000Z","updated_at":"2025-03-21T08:26:48.000Z","dependencies_parsed_at":"2022-09-19T09:41:49.802Z","dependency_job_id":null,"html_url":"https://github.com/itzmeanjan/kodr","commit_stats":null,"previous_names":[],"tags_count":5,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/itzmeanjan%2Fkodr","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/itzmeanjan%2Fkodr/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/itzmeanjan%2Fkodr/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/itzmeanjan%2Fkodr/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/itzmeanjan","download_url":"https://codeload.github.com/itzmeanjan/kodr/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":252973690,"owners_count":21834108,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["coding","decoding","encoding","erasure-coding","networkcoding","networking","randomlinearnetworkcoding","recoding","rlnc"],"created_at":"2024-10-03T18:15:22.457Z","updated_at":"2025-09-09T08:44:11.243Z","avatar_url":"https://github.com/itzmeanjan.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# kodr\n\n![kodr-logo](./img/logo.png)\n\nRandom Linear Network Coding\n\n## Motivation\n\nWhen I started looking into erasure coding techniques, I found many implementations of traditional block codes like Reed-Solomon codes or fountain codes like Raptor codes, though no implementation of **R**andom **L**inear **N**etwork **C**odes (RLNC) - which motivated me to take up this venture of writing **kodr**. I think RLNC is a great fit for large scale decentralized systems where peers talk to each other, store and retrieve data themselves, by crawling the Distributed Hash Table (DHT). I've a series of blogs on why RLNC is great, it begins @ https://itzmeanjan.in/pages/understanding-rlnc.html.\n\nThere are different variants of RLNC, each useful for certain application domain, the choice of using one comes with some tradeoffs. For now only ✅ marked variants are implemented in this package, though the goal is to eventually implement all of them ⏳.\n\n- Full RLNC ✅\n- Systematic RLNC ✅\n- On-the-fly RLNC\n- Sparse RLNC\n- Generational RLNC\n- Caterpillar RLNC\n\nFor learning basics of RLNC, you may want to go through my old blog post @ https://itzmeanjan.in/pages/rlnc-in-depth.html. During encoding, recoding and decoding, **kodr** interprets each byte of data as an element of finite field $GF(2^8)$. Why?\n\n- It's a good choice because from performance \u0026 memory consumption point of view, $GF(2^8)$ keeps a nice balance.\n- Working on larger finite field indeed decreases the chance of (randomly) generating linearly dependent pieces (which are useless during decoding), but requires more costly computation \u0026 if finite field operations are implemented using lookup tables then memory consumption increases to a great extent.\n- On the other hand, working on $GF(2)$, a much smaller field, increases the chance of generating linearly dependent pieces, though with sophisticated design like Fulcrum codes, they can be proved to be beneficial. \n- Another point is the larger the finite field, the higher is the cost of storing random sampled coding vectors.\n\nThis library provides easy to use API for encoding, recoding and decoding of arbitrary length data.\n\n## Installation\n\nAssuming you have Golang (\u003e=1.24) installed, add **kodr** as a dependency to your project,\n\n```bash\ngo get -u github.com/itzmeanjan/kodr/...\n```\n\n## Testing\n\nRun all the tests, from all the packages.\n\n```bash\ngo test -v -cover -count=10 ./...\n```\n\n## Benchmarking\n\nFor getting a picture of **kodr**'s performance, let's issue following commands.\n\n\u003e [!CAUTION]\n\u003e Ensure that you've disabled CPU frequency scaling, when benchmarking, following this guide @ https://github.com/google/benchmark/blob/main/docs/reducing_variance.md.\n\n```bash\n# Full RLNC\ngo test -run=xxx -bench=Encoder ./benches/full/\ngo test -run=xxx -bench=Recoder ./benches/full/\ngo test -run=xxx -bench=Decoder ./benches/full/\n\n# Systematic RLNC\ngo test -run=xxx -bench=Encoder ./benches/systematic\ngo test -run=xxx -bench=Decoder ./benches/systematic\n```\n\n\u003e [!NOTE]\n\u003e RLNC Decoder performance denotes, average time required for full data reconstruction from N-many coded pieces. From following tables, it's clear that, for a specific size of message, decoding complexity keeps increasing very fast as we increase number of pieces.\n\n### Full RLNC\n\n```bash\ngoos: linux\ngoarch: amd64\npkg: github.com/itzmeanjan/kodr/benches/full\ncpu: 12th Gen Intel(R) Core(TM) i7-1260P\nBenchmarkFullRLNCEncoder/1M/16_Pieces-16         \t    1324\t    880135 ns/op\t1265.86 MB/s\t   65600 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/1M/32_Pieces-16         \t    1300\t    880526 ns/op\t1228.10 MB/s\t   32848 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/1M/64_Pieces-16         \t    1320\t    873052 ns/op\t1219.89 MB/s\t   16496 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/1M/128_Pieces-16        \t    1359\t    867976 ns/op\t1217.66 MB/s\t    8368 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/1M/256_Pieces-16        \t    1303\t    868170 ns/op\t1212.81 MB/s\t    4400 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/16M/16_Pieces-16        \t      80\t  14504921 ns/op\t1228.95 MB/s\t 1048640 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/16M/32_Pieces-16        \t      79\t  14326616 ns/op\t1207.65 MB/s\t  524368 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/16M/64_Pieces-16        \t      80\t  14304505 ns/op\t1191.19 MB/s\t  262256 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/16M/128_Pieces-16       \t      82\t  14443587 ns/op\t1170.65 MB/s\t  131248 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/16M/256_Pieces-16       \t      81\t  14155676 ns/op\t1189.84 MB/s\t   65840 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/32M/16_Pieces-16        \t      40\t  28980124 ns/op\t1230.21 MB/s\t 2097216 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/32M/32_Pieces-16        \t      40\t  28965356 ns/op\t1194.64 MB/s\t 1048656 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/32M/64_Pieces-16        \t      40\t  29065528 ns/op\t1172.48 MB/s\t  524400 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/32M/128_Pieces-16       \t      40\t  28956767 ns/op\t1167.83 MB/s\t  262320 B/op\t       3 allocs/op\nBenchmarkFullRLNCEncoder/32M/256_Pieces-16       \t      40\t  28918111 ns/op\t1164.87 MB/s\t  131376 B/op\t       3 allocs/op\nPASS\nok  \tgithub.com/itzmeanjan/kodr/benches/full\t18.616s\n```\n\n```bash\ngoos: linux\ngoarch: amd64\npkg: github.com/itzmeanjan/kodr/benches/full\ncpu: 12th Gen Intel(R) Core(TM) i7-1260P\nBenchmarkFullRLNCRecoder/1M/16_Pieces-16         \t    1339\t    888852 ns/op\t1253.73 MB/s\t   65640 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/1M/32_Pieces-16         \t    1358\t    876789 ns/op\t1234.50 MB/s\t   32904 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/1M/64_Pieces-16         \t    1353\t    879587 ns/op\t1215.48 MB/s\t   16584 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/1M/128_Pieces-16        \t    1333\t    896799 ns/op\t1196.79 MB/s\t    8520 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/1M/256_Pieces-16        \t    1178\t   1020361 ns/op\t1096.15 MB/s\t    4680 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/16M/16_Pieces-16        \t      80\t  14806643 ns/op\t1203.92 MB/s\t 1048680 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/16M/32_Pieces-16        \t      81\t  14417283 ns/op\t1200.13 MB/s\t  524424 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/16M/64_Pieces-16        \t      84\t  14663685 ns/op\t1162.29 MB/s\t  262344 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/16M/128_Pieces-16       \t      78\t  14569035 ns/op\t1161.70 MB/s\t  131400 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/16M/256_Pieces-16       \t      79\t  15372783 ns/op\t1099.90 MB/s\t   66120 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/32M/16_Pieces-16        \t      39\t  31425659 ns/op\t1134.48 MB/s\t 2097256 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/32M/32_Pieces-16        \t      37\t  31162572 ns/op\t1110.44 MB/s\t 1048712 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/32M/64_Pieces-16        \t      38\t  31776846 ns/op\t1072.57 MB/s\t  524488 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/32M/128_Pieces-16       \t      37\t  30497395 ns/op\t1109.38 MB/s\t  262472 B/op\t       5 allocs/op\nBenchmarkFullRLNCRecoder/32M/256_Pieces-16       \t      37\t  31401920 ns/op\t1074.82 MB/s\t  131656 B/op\t       5 allocs/op\nPASS\nok  \tgithub.com/itzmeanjan/kodr/benches/full\t66.481s\n```\n\nNotice, how, with small number of pieces, decoding time stays afforable, even for large messages.\n\n```bash\ngoos: linux\ngoarch: amd64\npkg: github.com/itzmeanjan/kodr/benches/full\ncpu: 12th Gen Intel(R) Core(TM) i7-1260P\nBenchmarkFullRLNCDecoder/1M/16_Pieces-16         \t  168832\t         0.0000059 second/decode\nBenchmarkFullRLNCDecoder/1M/32_Pieces-16         \t   32136\t         0.0000328 second/decode\nBenchmarkFullRLNCDecoder/1M/64_Pieces-16         \t    4744\t         0.0002385 second/decode\nBenchmarkFullRLNCDecoder/1M/128_Pieces-16        \t     471\t         0.002227 second/decode\nBenchmarkFullRLNCDecoder/1M/256_Pieces-16        \t      16\t         0.06368 second/decode\nBenchmarkFullRLNCDecoder/2M/16_Pieces-16         \t  151488\t         0.0000067 second/decode\nBenchmarkFullRLNCDecoder/2M/32_Pieces-16         \t   26246\t         0.0000411 second/decode\nBenchmarkFullRLNCDecoder/2M/64_Pieces-16         \t    2848\t         0.0003575 second/decode\nBenchmarkFullRLNCDecoder/2M/128_Pieces-16        \t     123\t         0.008466 second/decode\nBenchmarkFullRLNCDecoder/2M/256_Pieces-16        \t       2\t         0.6190 second/decode\nBenchmarkFullRLNCDecoder/16M/16_Pieces-16        \t   24030\t         0.0000427 second/decode\nBenchmarkFullRLNCDecoder/16M/32_Pieces-16        \t       2\t         0.5769 second/decode\nBenchmarkFullRLNCDecoder/16M/64_Pieces-16        \t       1\t         1.594 second/decode\nBenchmarkFullRLNCDecoder/16M/128_Pieces-16       \t       1\t         3.355 second/decode\nBenchmarkFullRLNCDecoder/16M/256_Pieces-16       \t       1\t         6.483 second/decode\nBenchmarkFullRLNCDecoder/32M/16_Pieces-16        \t       2\t         0.5767 second/decode\nBenchmarkFullRLNCDecoder/32M/32_Pieces-16        \t       1\t         1.619 second/decode\nBenchmarkFullRLNCDecoder/32M/64_Pieces-16        \t       1\t         3.233 second/decode\nBenchmarkFullRLNCDecoder/32M/128_Pieces-16       \t       1\t         6.540 second/decode\nBenchmarkFullRLNCDecoder/32M/256_Pieces-16       \t       1\t        13.07 second/decode\nPASS\nok  \tgithub.com/itzmeanjan/kodr/benches/full\t214.901s\n```\n\n### Systematic RLNC\n\n```bash\ngoos: linux\ngoarch: amd64\npkg: github.com/itzmeanjan/kodr/benches/systematic\ncpu: 12th Gen Intel(R) Core(TM) i7-1260P\nBenchmarkSystematicRLNCEncoder/1M/16Pieces-16         \t    1558\t    871583 ns/op\t1278.28 MB/s\t   65600 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/1M/32Pieces-16         \t    1872\t    891196 ns/op\t1213.40 MB/s\t   32848 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/1M/64Pieces-16         \t    3626\t    907845 ns/op\t1173.13 MB/s\t   16496 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/1M/128Pieces-16        \t   10000\t    901206 ns/op\t1172.76 MB/s\t    8368 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/1M/256Pieces-16        \t   10000\t    915287 ns/op\t1150.38 MB/s\t    4400 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/2M/16Pieces-16         \t     754\t   1802635 ns/op\t1236.10 MB/s\t  131136 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/2M/32Pieces-16         \t     942\t   1806803 ns/op\t1196.99 MB/s\t   65616 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/2M/64Pieces-16         \t    1617\t   1794285 ns/op\t1187.09 MB/s\t   32880 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/2M/128Pieces-16        \t   10000\t   1883371 ns/op\t1122.28 MB/s\t   16560 B/op\t       3 allocs/op\nBenchmarkSystematicRLNCEncoder/2M/256Pieces-16        \t   10000\t   1866660 ns/op\t1128.00 MB/s\t    8496 B/op\t       3 allocs/op\nPASS\nok  \tgithub.com/itzmeanjan/kodr/benches/systematic\t68.564s\n```\n\nSystematic RLNC Decoder has an advantage over Full RLNC Decoder - as it may get some pieces which are actually uncoded, just augmented to be coded, it doesn't need to process those pieces. Rather it'll use uncoded pieces to decode other coded pieces much faster.\n\n```bash\ngoos: linux\ngoarch: amd64\npkg: github.com/itzmeanjan/kodr/benches/systematic\ncpu: 12th Gen Intel(R) Core(TM) i7-1260P\nBenchmarkSystematicRLNCDecoder/1M/16Pieces-16         \t  172687\t         0.0000057 second/decode\nBenchmarkSystematicRLNCDecoder/1M/32Pieces-16         \t   34538\t         0.0000306 second/decode\nBenchmarkSystematicRLNCDecoder/1M/64Pieces-16         \t    4858\t         0.0002176 second/decode\nBenchmarkSystematicRLNCDecoder/1M/128Pieces-16        \t     702\t         0.001684 second/decode\nBenchmarkSystematicRLNCDecoder/1M/256Pieces-16        \t      68\t         0.01578 second/decode\nBenchmarkSystematicRLNCDecoder/2M/16Pieces-16         \t  157543\t         0.0000061 second/decode\nBenchmarkSystematicRLNCDecoder/2M/32Pieces-16         \t   29428\t         0.0000340 second/decode\nBenchmarkSystematicRLNCDecoder/2M/64Pieces-16         \t    4324\t         0.0002572 second/decode\nBenchmarkSystematicRLNCDecoder/2M/128Pieces-16        \t     452\t         0.002349 second/decode\nBenchmarkSystematicRLNCDecoder/2M/256Pieces-16        \t       6\t         0.1677 second/decode\nBenchmarkSystematicRLNCDecoder/16M/16_Pieces-16       \t   85780\t         0.0000119 second/decode\nBenchmarkSystematicRLNCDecoder/16M/32_Pieces-16       \t    2791\t         0.0003615 second/decode\nBenchmarkSystematicRLNCDecoder/16M/64_Pieces-16       \t       2\t         0.6944 second/decode\nBenchmarkSystematicRLNCDecoder/16M/128_Pieces-16      \t       1\t         1.821 second/decode\nBenchmarkSystematicRLNCDecoder/16M/256_Pieces-16      \t       1\t         3.445 second/decode\nBenchmarkSystematicRLNCDecoder/32M/16_Pieces-16       \t    8276\t         0.0001264 second/decode\nBenchmarkSystematicRLNCDecoder/32M/32_Pieces-16       \t       2\t         0.6811 second/decode\nBenchmarkSystematicRLNCDecoder/32M/64_Pieces-16       \t       1\t         1.789 second/decode\nBenchmarkSystematicRLNCDecoder/32M/128_Pieces-16      \t       1\t         3.423 second/decode\nBenchmarkSystematicRLNCDecoder/32M/256_Pieces-16      \t       1\t         6.593 second/decode\nPASS\nok  \tgithub.com/itzmeanjan/kodr/benches/systematic\t195.287s\n```\n\n## Usage\n\nFollowing examples demonstrate how to use Random Linear Network Coding (RLNC) API exposed by **kodr**.\n\n### Full RLNC\n\n**Example program:** [examples/full/main.go](./examples/full/main.go)\n\n- Read image into memory.\n- Split in-memory image data into 64 equal length pieces, full RLNC code them, get 128 coded pieces.\n- Randomly drop 32 of those coded pieces, use remaining 96 of them, to recode into 192 coded pieces.\n- Random shuffle those, drop 96 of those, work with remaining 96 coded pieces, simulating reception of those pieces at reconstruction site.\n- RLNC decoder takes first 64 linearly independent coded pieces to reconstruct original data.\n- Computing a cryptographic message digest over both original image and decoded image, results in the same digest.\n\nFor running this example\n\n```bash\npushd examples/full\ngo run main.go\npopd\n```\n\n```bash\n2025/06/25 13:14:10 Reading from ../../img/logo.png\n2025/06/25 13:14:10 Read 3965 bytes\n2025/06/25 13:14:10 SHA3-256: 0x73de1a7f05fa9db95302ae9041ca423539b8d45e36be937fd99becf74229d29e\n\n2025/06/25 13:14:10 Coding 64 pieces together\n2025/06/25 13:14:10 Coded into 128 pieces\n2025/06/25 13:14:10 Dropped 32 pieces, remaining 96 pieces\n\n2025/06/25 13:14:10 Recoded 96 coded pieces into 192 pieces\n2025/06/25 13:14:10 Shuffled 192 coded pieces\n2025/06/25 13:14:10 Dropped 96 pieces, remaining 96 pieces\n\n2025/06/25 13:14:10 Decoding with 64 pieces\n2025/06/25 13:14:10 Decoded into 3968 bytes\n2025/06/25 13:14:10 First 3965 bytes of decoded data matches original 3965 bytes\n2025/06/25 13:14:10 3 bytes of padding: [0 0 0]\n\n2025/06/25 13:14:10 SHA3-256: 0x73de1a7f05fa9db95302ae9041ca423539b8d45e36be937fd99becf74229d29e\n2025/06/25 13:14:10 Wrote 3965 bytes into `./recovered.png`\n```\n\nThis should generate `examples/full/recovered.png`, which is exactly same as `img/logo.png`.\n\n---\n\n### Systematic RLNC\n\n**Example program:** [examples/systematic/main.go](./examples/systematic/main.go)\n\n- Random generate some values, filling fields of a struct, which can be serialized to JSON.\n- Split JSON serialized data into N pieces, each of size 8 -bytes.\n- Use systematic RLNC coder to encode these pieces s.t. first N-many pieces (here N = 310), are kept uncoded though they're augmented to be coded by providing with coding vector which has only one non-zero element. Next coded pieces i.e. \u003e310th, carry randomly generated coding vectors as usual.\n- Simulate loss of some coded pieces, by randomly selecting which piece to use for decoding.\n- Computing a cryptographic message digest over both original JSON serialized data and recovered data, results in the same digest.\n\nFor running this example\n\n```bash\npushd examples/systematic\ngo run main.go\npopd\n```\n\n```bash\n2025/06/25 13:14:24 Original serialised data of 2438 bytes\n2025/06/25 13:14:24 SHA3-256(original): 0xd321ed51df0c5119acc3e73ce7bc5ea7ae3c92900387eb65445006b924b8f5da\n2025/06/25 13:14:24 305 pieces being coded together, each of 8 bytes\n2025/06/25 13:14:24 2 bytes of padding used\n\n2025/06/25 13:14:24 95465 bytes of coded data to be consumed for successful decoding\n2025/06/25 13:14:24 Recovered 2440 ( = 2438 + 2 ) bytes flattened data\n2025/06/25 13:14:24 SHA3-256(recovered): 0xd321ed51df0c5119acc3e73ce7bc5ea7ae3c92900387eb65445006b924b8f5da\n```\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fitzmeanjan%2Fkodr","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fitzmeanjan%2Fkodr","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fitzmeanjan%2Fkodr/lists"}