📄 SubscriptionManager.sol
D-OPEN SOVEREIGN
1/*
2 * Copyright (c) 2026 DataPond D-Library Pty Ltd. ("The Sanctuary")
3 * Non-Profit Public Library — The World Library
4 *
5 * D-SAFE Certification issued by POND Enterprise.
6 * Published under the D-Open Code Sovereign Licence v1.0 framework
7 * DataPond D-Library All exclusive Right reserved on modifiying the code - CC Attribution to data pond, Non modifiable, Non Commercial.
8 * https://registry.world.bibliotech.com/licence
9 * Source code donated to DataPond D-Library by it's author: data pond.
10 *
11 * Technical Guardian ("The Shield"): Pond Enterprise Pty Ltd. (ACN 694 747 987)
12 * All liability claims about D-SAFE certification issues coming from the published D-Safe direction must be addressed with Pond Enterprise Pty Ltd.
13 * Code Modification automatically voids the certified liability protection provided by Pond Enterprise.
14 */
15
16// SPDX-License-Identifier: MIT
17pragma solidity ^0.8.20;
18
19interface IBackupStorage {
20 function isRegistered(uint32 userId) external view returns (bool);
21 function userLevel(uint32 userId) external view returns (uint8);
22}
23
24contract SubscriptionManager {
25 error AlreadySubscribed();
26 error NotSubscribed();
27
28 IBackupStorage public immutable backupStorage;
29
30 uint256 public constant MAX_BFS_NODES = 1000;
31 uint256 public constant DAMPENING_NUMERATOR = 850_000;
32 uint256 public constant DAMPENING_DENOMINATOR = 1_000_000;
33
34 mapping(uint32 => uint256) private _directScore;
35 mapping(uint32 => uint32[]) private _subscriptions;
36 mapping(bytes32 => bool) private _isSubscribed;
37
38 struct Receipt {
39 uint32[] nodes;
40 uint256[] credits;
41 }
42 mapping(bytes32 => Receipt) private _receipts;
43
44 mapping(address => bool) public isAuthorized;
45 address public admin;
46
47 event AuthorizedAdded(address indexed caller);
48 event AuthorizedRemoved(address indexed caller);
49
50 modifier onlyAdmin() {
51 require(msg.sender == admin, "not admin");
52 _;
53 }
54
55 modifier onlyAuthorized() {
56 require(isAuthorized[msg.sender] || msg.sender == admin, "not authorized");
57 _;
58 }
59
60 constructor(address backupStorageAddress) {
61 backupStorage = IBackupStorage(backupStorageAddress);
62 admin = msg.sender;
63 }
64
65 function addAuthorized(address caller) external onlyAdmin {
66 require(caller != address(0), "zero addr");
67 isAuthorized[caller] = true;
68 emit AuthorizedAdded(caller);
69 }
70
71 function removeAuthorized(address caller) external onlyAdmin {
72 isAuthorized[caller] = false;
73 emit AuthorizedRemoved(caller);
74 }
75
76 function getEdgeId(uint32 subscriber, uint32 target) public pure returns (bytes32 id) {
77 assembly {
78 mstore(0x00, shl(224, subscriber))
79 mstore(0x04, shl(224, target))
80 id := keccak256(0x00, 0x08)
81 }
82 }
83
84 function scoreOf(uint32 userId) external view returns (uint256) {
85 return _directScore[userId];
86 }
87
88 function getSubscriptions(uint32 subscriber) external view returns (uint32[] memory) {
89 return _subscriptions[subscriber];
90 }
91
92 function getSubscriptionCount(uint32 subscriber) external view returns (uint256) {
93 return _subscriptions[subscriber].length;
94 }
95
96 function isSubscribed(uint32 subscriber, uint32 target) external view returns (bool) {
97 return _isSubscribed[getEdgeId(subscriber, target)];
98 }
99
100 function subscribeTo(uint32 subscriber, uint32 target) external onlyAuthorized {
101 bytes32 edgeId = getEdgeId(subscriber, target);
102 if (_isSubscribed[edgeId]) revert AlreadySubscribed();
103
104 if (!backupStorage.isRegistered(subscriber) || !backupStorage.isRegistered(target)) {
105 _subscriptions[subscriber].push(target);
106 _isSubscribed[edgeId] = true;
107 return;
108 }
109
110 uint8 lvl = backupStorage.userLevel(subscriber);
111 uint256 initialCredit = _getLevelWeight(lvl);
112
113 _subscriptions[subscriber].push(target);
114 _isSubscribed[edgeId] = true;
115
116 uint256 outDeg = _subscriptions[subscriber].length;
117 if (outDeg > 0) {
118 initialCredit = initialCredit / outDeg;
119 }
120
121 (uint32[] memory discovered, uint256[] memory credits) = _calculateDP(target, initialCredit);
122
123 Receipt storage receipt = _receipts[edgeId];
124 receipt.nodes = discovered;
125 receipt.credits = credits;
126
127 uint256 discLen = discovered.length;
128 for (uint256 i = 0; i < discLen;) {
129 _directScore[discovered[i]] += credits[i];
130 unchecked { ++i; }
131 }
132 }
133
134 function unsubscribeFrom(uint32 subscriber, uint32 target) external onlyAuthorized {
135 bytes32 edgeId = getEdgeId(subscriber, target);
136 if (!_isSubscribed[edgeId]) revert NotSubscribed();
137
138 uint32[] storage subs = _subscriptions[subscriber];
139 uint256 subsLen = subs.length;
140 for (uint256 i = 0; i < subsLen;) {
141 if (subs[i] == target) {
142 subs[i] = subs[subs.length - 1];
143 subs.pop();
144 break;
145 }
146 unchecked { ++i; }
147 }
148 _isSubscribed[edgeId] = false;
149
150 Receipt storage receipt = _receipts[edgeId];
151 uint256 nodesLen = receipt.nodes.length;
152 for (uint256 i = 0; i < nodesLen;) {
153 _directScore[receipt.nodes[i]] -= receipt.credits[i];
154 unchecked { ++i; }
155 }
156 delete _receipts[edgeId];
157 }
158
159 function _indexOf(uint32[] memory arr, uint256 count, uint32 val) internal pure returns (uint256) {
160 for(uint256 i = 0; i < count;) {
161 if(arr[i] == val) return i;
162 unchecked { ++i; }
163 }
164 return type(uint256).max;
165 }
166
167 function _calculateDP(uint32 startNode, uint256 initialCredit) internal view returns (uint32[] memory, uint256[] memory) {
168 uint32[] memory queue = new uint32[](MAX_BFS_NODES + 1);
169 uint32[] memory discovered = new uint32[](MAX_BFS_NODES);
170 uint256 head = 0;
171 uint256 tail = 0;
172 uint256 discCount = 0;
173
174 queue[tail++] = startNode;
175 discovered[discCount++] = startNode;
176
177 while (head < tail && discCount < MAX_BFS_NODES) {
178 uint32 u = queue[head++];
179 uint32[] storage children = _subscriptions[u];
180 uint256 childLen = children.length;
181 for (uint256 i = 0; i < childLen;) {
182 uint32 v = children[i];
183 if (backupStorage.isRegistered(v)) {
184 if (_indexOf(discovered, discCount, v) == type(uint256).max) {
185 if (discCount < MAX_BFS_NODES) {
186 discovered[discCount++] = v;
187 queue[tail++] = v;
188 }
189 }
190 }
191 unchecked { ++i; }
192 }
193 }
194
195 uint256[] memory inDeg = new uint256[](discCount);
196 for (uint256 i = 0; i < discCount;) {
197 uint32 u = discovered[i];
198 uint32[] storage children = _subscriptions[u];
199 uint256 childLen = children.length;
200 for (uint256 j = 0; j < childLen;) {
201 uint32 v = children[j];
202 uint256 vIndex = _indexOf(discovered, discCount, v);
203 if (vIndex != type(uint256).max) {
204 inDeg[vIndex]++;
205 }
206 unchecked { ++j; }
207 }
208 unchecked { ++i; }
209 }
210
211 uint256[] memory credit = new uint256[](discCount);
212 bool[] memory processed = new bool[](discCount);
213 credit[0] = initialCredit;
214
215 head = 0;
216 tail = 0;
217 for (uint256 i = 0; i < discCount;) {
218 if (inDeg[i] == 0) {
219 queue[tail++] = uint32(i);
220 }
221 unchecked { ++i; }
222 }
223
224 uint256[] memory finalizedCredit = new uint256[](discCount);
225 uint256 processedCount = 0;
226 uint256 breakerIndex = 0;
227
228 while (processedCount < discCount) {
229 if (head == tail) {
230 while (breakerIndex < discCount && processed[breakerIndex]) {
231 breakerIndex++;
232 }
233 if (breakerIndex < discCount) {
234 queue[tail++] = uint32(breakerIndex);
235 } else {
236 break;
237 }
238 }
239
240 uint32 uIndex = queue[head++];
241 if (processed[uIndex]) {
242 continue;
243 }
244 processed[uIndex] = true;
245 processedCount++;
246
247 uint32 u = discovered[uIndex];
248 uint256 uCredit = credit[uIndex];
249 finalizedCredit[uIndex] = uCredit;
250
251 if (uCredit > 0) {
252 uint32[] storage children = _subscriptions[u];
253 uint256 outDeg = children.length;
254 if (outDeg > 0) {
255 uint256 childCredit = (uCredit * DAMPENING_NUMERATOR) / (DAMPENING_DENOMINATOR * outDeg);
256 for (uint256 i = 0; i < outDeg;) {
257 uint256 vIndex = _indexOf(discovered, discCount, children[i]);
258 if (vIndex != type(uint256).max) {
259 credit[vIndex] += childCredit;
260 if (inDeg[vIndex] > 0) {
261 inDeg[vIndex]--;
262 if (inDeg[vIndex] == 0) {
263 queue[tail++] = uint32(vIndex);
264 }
265 }
266 }
267 unchecked { ++i; }
268 }
269 }
270 }
271 }
272
273 uint32[] memory finalDiscovered = new uint32[](discCount);
274 uint256[] memory finalCredits = new uint256[](discCount);
275 for (uint256 i = 0; i < discCount;) {
276 finalDiscovered[i] = discovered[i];
277 finalCredits[i] = finalizedCredit[i];
278 unchecked { ++i; }
279 }
280
281 return (finalDiscovered, finalCredits);
282 }
283
284 function _getLevelWeight(uint8 level) internal pure returns (uint256) {
285 if (level <= 127) {
286 if (level <= 63) {
287 if (level <= 31) {
288 if (level <= 15) {
289 if (level <= 7) {
290 if (level <= 3) {
291 if (level <= 1) {
292 if (level <= 0) {
293 return 0;
294 } else {
295 return 1000000;
296 }
297 } else {
298 if (level <= 2) {
299 return 1018295;
300 } else {
301 return 1036926;
302 }
303 }
304 } else {
305 if (level <= 5) {
306 if (level <= 4) {
307 return 1055898;
308 } else {
309 return 1075216;
310 }
311 } else {
312 if (level <= 6) {
313 return 1094888;
314 } else {
315 return 1114920;
316 }
317 }
318 }
319 } else {
320 if (level <= 11) {
321 if (level <= 9) {
322 if (level <= 8) {
323 return 1135319;
324 } else {
325 return 1156091;
326 }
327 } else {
328 if (level <= 10) {
329 return 1177243;
330 } else {
331 return 1198781;
332 }
333 }
334 } else {
335 if (level <= 13) {
336 if (level <= 12) {
337 return 1220714;
338 } else {
339 return 1243048;
340 }
341 } else {
342 if (level <= 14) {
343 return 1265791;
344 } else {
345 return 1288950;
346 }
347 }
348 }
349 }
350 } else {
351 if (level <= 23) {
352 if (level <= 19) {
353 if (level <= 17) {
354 if (level <= 16) {
355 return 1312533;
356 } else {
357 return 1336547;
358 }
359 } else {
360 if (level <= 18) {
361 return 1361000;
362 } else {
363 return 1385901;
364 }
365 }
366 } else {
367 if (level <= 21) {
368 if (level <= 20) {
369 return 1411257;
370 } else {
371 return 1437077;
372 }
373 } else {
374 if (level <= 22) {
375 return 1463370;
376 } else {
377 return 1490144;
378 }
379 }
380 }
381 } else {
382 if (level <= 27) {
383 if (level <= 25) {
384 if (level <= 24) {
385 return 1517407;
386 } else {
387 return 1545170;
388 }
389 } else {
390 if (level <= 26) {
391 return 1573440;
392 } else {
393 return 1602228;
394 }
395 }
396 } else {
397 if (level <= 29) {
398 if (level <= 28) {
399 return 1631542;
400 } else {
401 return 1661393;
402 }
403 } else {
404 if (level <= 30) {
405 return 1691790;
406 } else {
407 return 1722742;
408 }
409 }
410 }
411 }
412 }
413 } else {
414 if (level <= 47) {
415 if (level <= 39) {
416 if (level <= 35) {
417 if (level <= 33) {
418 if (level <= 32) {
419 return 1754262;
420 } else {
421 return 1786358;
422 }
423 } else {
424 if (level <= 34) {
425 return 1819041;
426 } else {
427 return 1852322;
428 }
429 }
430 } else {
431 if (level <= 37) {
432 if (level <= 36) {
433 return 1886212;
434 } else {
435 return 1920722;
436 }
437 } else {
438 if (level <= 38) {
439 return 1955863;
440 } else {
441 return 1991648;
442 }
443 }
444 }
445 } else {
446 if (level <= 43) {
447 if (level <= 41) {
448 if (level <= 40) {
449 return 2028087;
450 } else {
451 return 2065192;
452 }
453 } else {
454 if (level <= 42) {
455 return 2102977;
456 } else {
457 return 2141453;
458 }
459 }
460 } else {
461 if (level <= 45) {
462 if (level <= 44) {
463 return 2180633;
464 } else {
465 return 2220530;
466 }
467 } else {
468 if (level <= 46) {
469 return 2261156;
470 } else {
471 return 2302526;
472 }
473 }
474 }
475 }
476 } else {
477 if (level <= 55) {
478 if (level <= 51) {
479 if (level <= 49) {
480 if (level <= 48) {
481 return 2344653;
482 } else {
483 return 2387551;
484 }
485 } else {
486 if (level <= 50) {
487 return 2431234;
488 } else {
489 return 2475715;
490 }
491 }
492 } else {
493 if (level <= 53) {
494 if (level <= 52) {
495 return 2521011;
496 } else {
497 return 2567135;
498 }
499 } else {
500 if (level <= 54) {
501 return 2614103;
502 } else {
503 return 2661931;
504 }
505 }
506 }
507 } else {
508 if (level <= 59) {
509 if (level <= 57) {
510 if (level <= 56) {
511 return 2710633;
512 } else {
513 return 2760227;
514 }
515 } else {
516 if (level <= 58) {
517 return 2810728;
518 } else {
519 return 2862153;
520 }
521 }
522 } else {
523 if (level <= 61) {
524 if (level <= 60) {
525 return 2914519;
526 } else {
527 return 2967843;
528 }
529 } else {
530 if (level <= 62) {
531 return 3022142;
532 } else {
533 return 3077435;
534 }
535 }
536 }
537 }
538 }
539 }
540 } else {
541 if (level <= 95) {
542 if (level <= 79) {
543 if (level <= 71) {
544 if (level <= 67) {
545 if (level <= 65) {
546 if (level <= 64) {
547 return 3133740;
548 } else {
549 return 3191074;
550 }
551 } else {
552 if (level <= 66) {
553 return 3249458;
554 } else {
555 return 3308910;
556 }
557 }
558 } else {
559 if (level <= 69) {
560 if (level <= 68) {
561 return 3369450;
562 } else {
563 return 3431097;
564 }
565 } else {
566 if (level <= 70) {
567 return 3493872;
568 } else {
569 return 3557796;
570 }
571 }
572 }
573 } else {
574 if (level <= 75) {
575 if (level <= 73) {
576 if (level <= 72) {
577 return 3622889;
578 } else {
579 return 3689173;
580 }
581 } else {
582 if (level <= 74) {
583 return 3756670;
584 } else {
585 return 3825402;
586 }
587 }
588 } else {
589 if (level <= 77) {
590 if (level <= 76) {
591 return 3895392;
592 } else {
593 return 3966662;
594 }
595 } else {
596 if (level <= 78) {
597 return 4039235;
598 } else {
599 return 4113137;
600 }
601 }
602 }
603 }
604 } else {
605 if (level <= 87) {
606 if (level <= 83) {
607 if (level <= 81) {
608 if (level <= 80) {
609 return 4188391;
610 } else {
611 return 4265021;
612 }
613 } else {
614 if (level <= 82) {
615 return 4343054;
616 } else {
617 return 4422514;
618 }
619 }
620 } else {
621 if (level <= 85) {
622 if (level <= 84) {
623 return 4503428;
624 } else {
625 return 4585823;
626 }
627 } else {
628 if (level <= 86) {
629 return 4669725;
630 } else {
631 return 4755162;
632 }
633 }
634 }
635 } else {
636 if (level <= 91) {
637 if (level <= 89) {
638 if (level <= 88) {
639 return 4842162;
640 } else {
641 return 4930754;
642 }
643 } else {
644 if (level <= 90) {
645 return 5020967;
646 } else {
647 return 5112830;
648 }
649 }
650 } else {
651 if (level <= 93) {
652 if (level <= 92) {
653 return 5206374;
654 } else {
655 return 5301630;
656 }
657 } else {
658 if (level <= 94) {
659 return 5398628;
660 } else {
661 return 5497401;
662 }
663 }
664 }
665 }
666 }
667 } else {
668 if (level <= 111) {
669 if (level <= 103) {
670 if (level <= 99) {
671 if (level <= 97) {
672 if (level <= 96) {
673 return 5597981;
674 } else {
675 return 5700402;
676 }
677 } else {
678 if (level <= 98) {
679 return 5804696;
680 } else {
681 return 5910899;
682 }
683 }
684 } else {
685 if (level <= 101) {
686 if (level <= 100) {
687 return 6019044;
688 } else {
689 return 6129168;
690 }
691 } else {
692 if (level <= 102) {
693 return 6241307;
694 } else {
695 return 6355498;
696 }
697 }
698 }
699 } else {
700 if (level <= 107) {
701 if (level <= 105) {
702 if (level <= 104) {
703 return 6471778;
704 } else {
705 return 6590185;
706 }
707 } else {
708 if (level <= 106) {
709 return 6710759;
710 } else {
711 return 6833538;
712 }
713 }
714 } else {
715 if (level <= 109) {
716 if (level <= 108) {
717 return 6958564;
718 } else {
719 return 7085878;
720 }
721 } else {
722 if (level <= 110) {
723 return 7215521;
724 } else {
725 return 7347536;
726 }
727 }
728 }
729 }
730 } else {
731 if (level <= 119) {
732 if (level <= 115) {
733 if (level <= 113) {
734 if (level <= 112) {
735 return 7481966;
736 } else {
737 return 7618855;
738 }
739 } else {
740 if (level <= 114) {
741 return 7758250;
742 } else {
743 return 7900194;
744 }
745 }
746 } else {
747 if (level <= 117) {
748 if (level <= 116) {
749 return 8044736;
750 } else {
751 return 8191922;
752 }
753 } else {
754 if (level <= 118) {
755 return 8341801;
756 } else {
757 return 8494422;
758 }
759 }
760 }
761 } else {
762 if (level <= 123) {
763 if (level <= 121) {
764 if (level <= 120) {
765 return 8649836;
766 } else {
767 return 8808092;
768 }
769 } else {
770 if (level <= 122) {
771 return 8969245;
772 } else {
773 return 9133346;
774 }
775 }
776 } else {
777 if (level <= 125) {
778 if (level <= 124) {
779 return 9300449;
780 } else {
781 return 9470610;
782 }
783 } else {
784 if (level <= 126) {
785 return 9643883;
786 } else {
787 return 9820327;
788 }
789 }
790 }
791 }
792 }
793 }
794 }
795 } else {
796 if (level <= 191) {
797 if (level <= 159) {
798 if (level <= 143) {
799 if (level <= 135) {
800 if (level <= 131) {
801 if (level <= 129) {
802 if (level <= 128) {
803 return 10000000;
804 } else {
805 return 10182959;
806 }
807 } else {
808 if (level <= 130) {
809 return 10369266;
810 } else {
811 return 10558981;
812 }
813 }
814 } else {
815 if (level <= 133) {
816 if (level <= 132) {
817 return 10752168;
818 } else {
819 return 10948889;
820 }
821 } else {
822 if (level <= 134) {
823 return 11149209;
824 } else {
825 return 11353195;
826 }
827 }
828 }
829 } else {
830 if (level <= 139) {
831 if (level <= 137) {
832 if (level <= 136) {
833 return 11560912;
834 } else {
835 return 11772430;
836 }
837 } else {
838 if (level <= 138) {
839 return 11987818;
840 } else {
841 return 12207146;
842 }
843 }
844 } else {
845 if (level <= 141) {
846 if (level <= 140) {
847 return 12430488;
848 } else {
849 return 12657915;
850 }
851 } else {
852 if (level <= 142) {
853 return 12889504;
854 } else {
855 return 13125330;
856 }
857 }
858 }
859 }
860 } else {
861 if (level <= 151) {
862 if (level <= 147) {
863 if (level <= 145) {
864 if (level <= 144) {
865 return 13365470;
866 } else {
867 return 13610004;
868 }
869 } else {
870 if (level <= 146) {
871 return 13859012;
872 } else {
873 return 14112576;
874 }
875 }
876 } else {
877 if (level <= 149) {
878 if (level <= 148) {
879 return 14370779;
880 } else {
881 return 14633706;
882 }
883 } else {
884 if (level <= 150) {
885 return 14901443;
886 } else {
887 return 15174079;
888 }
889 }
890 }
891 } else {
892 if (level <= 155) {
893 if (level <= 153) {
894 if (level <= 152) {
895 return 15451703;
896 } else {
897 return 15734407;
898 }
899 } else {
900 if (level <= 154) {
901 return 16022283;
902 } else {
903 return 16315426;
904 }
905 }
906 } else {
907 if (level <= 157) {
908 if (level <= 156) {
909 return 16613932;
910 } else {
911 return 16917900;
912 }
913 } else {
914 if (level <= 158) {
915 return 17227429;
916 } else {
917 return 17542621;
918 }
919 }
920 }
921 }
922 }
923 } else {
924 if (level <= 175) {
925 if (level <= 167) {
926 if (level <= 163) {
927 if (level <= 161) {
928 if (level <= 160) {
929 return 17863580;
930 } else {
931 return 18190411;
932 }
933 } else {
934 if (level <= 162) {
935 return 18523222;
936 } else {
937 return 18862122;
938 }
939 }
940 } else {
941 if (level <= 165) {
942 if (level <= 164) {
943 return 19207222;
944 } else {
945 return 19558636;
946 }
947 } else {
948 if (level <= 166) {
949 return 19916480;
950 } else {
951 return 20280871;
952 }
953 }
954 }
955 } else {
956 if (level <= 171) {
957 if (level <= 169) {
958 if (level <= 168) {
959 return 20651929;
960 } else {
961 return 21029775;
962 }
963 } else {
964 if (level <= 170) {
965 return 21414535;
966 } else {
967 return 21806334;
968 }
969 }
970 } else {
971 if (level <= 173) {
972 if (level <= 172) {
973 return 22205302;
974 } else {
975 return 22611569;
976 }
977 } else {
978 if (level <= 174) {
979 return 23025269;
980 } else {
981 return 23446538;
982 }
983 }
984 }
985 }
986 } else {
987 if (level <= 183) {
988 if (level <= 179) {
989 if (level <= 177) {
990 if (level <= 176) {
991 return 23875515;
992 } else {
993 return 24312340;
994 }
995 } else {
996 if (level <= 178) {
997 return 24757157;
998 } else {
999 return 25210113;
1000 }
1001 }
1002 } else {
1003 if (level <= 181) {
1004 if (level <= 180) {
1005 return 25671356;
1006 } else {
1007 return 26141038;
1008 }
1009 } else {
1010 if (level <= 182) {
1011 return 26619313;
1012 } else {
1013 return 27106339;
1014 }
1015 }
1016 }
1017 } else {
1018 if (level <= 187) {
1019 if (level <= 185) {
1020 if (level <= 184) {
1021 return 27602275;
1022 } else {
1023 return 28107285;
1024 }
1025 } else {
1026 if (level <= 186) {
1027 return 28621534;
1028 } else {
1029 return 29145192;
1030 }
1031 }
1032 } else {
1033 if (level <= 189) {
1034 if (level <= 188) {
1035 return 29678431;
1036 } else {
1037 return 30221426;
1038 }
1039 } else {
1040 if (level <= 190) {
1041 return 30774356;
1042 } else {
1043 return 31337402;
1044 }
1045 }
1046 }
1047 }
1048 }
1049 }
1050 } else {
1051 if (level <= 223) {
1052 if (level <= 207) {
1053 if (level <= 199) {
1054 if (level <= 195) {
1055 if (level <= 193) {
1056 if (level <= 192) {
1057 return 31910749;
1058 } else {
1059 return 32494587;
1060 }
1061 } else {
1062 if (level <= 194) {
1063 return 33089106;
1064 } else {
1065 return 33694503;
1066 }
1067 }
1068 } else {
1069 if (level <= 197) {
1070 if (level <= 196) {
1071 return 34310975;
1072 } else {
1073 return 34938727;
1074 }
1075 } else {
1076 if (level <= 198) {
1077 return 35577964;
1078 } else {
1079 return 36228897;
1080 }
1081 }
1082 }
1083 } else {
1084 if (level <= 203) {
1085 if (level <= 201) {
1086 if (level <= 200) {
1087 return 36891739;
1088 } else {
1089 return 37566708;
1090 }
1091 } else {
1092 if (level <= 202) {
1093 return 38254027;
1094 } else {
1095 return 38953921;
1096 }
1097 }
1098 } else {
1099 if (level <= 205) {
1100 if (level <= 204) {
1101 return 39666620;
1102 } else {
1103 return 40392358;
1104 }
1105 } else {
1106 if (level <= 206) {
1107 return 41131375;
1108 } else {
1109 return 41883912;
1110 }
1111 }
1112 }
1113 }
1114 } else {
1115 if (level <= 215) {
1116 if (level <= 211) {
1117 if (level <= 209) {
1118 if (level <= 208) {
1119 return 42650218;
1120 } else {
1121 return 43430544;
1122 }
1123 } else {
1124 if (level <= 210) {
1125 return 44225147;
1126 } else {
1127 return 45034288;
1128 }
1129 }
1130 } else {
1131 if (level <= 213) {
1132 if (level <= 212) {
1133 return 45858233;
1134 } else {
1135 return 46697253;
1136 }
1137 } else {
1138 if (level <= 214) {
1139 return 47551624;
1140 } else {
1141 return 48421626;
1142 }
1143 }
1144 }
1145 } else {
1146 if (level <= 219) {
1147 if (level <= 217) {
1148 if (level <= 216) {
1149 return 49307545;
1150 } else {
1151 return 50209673;
1152 }
1153 } else {
1154 if (level <= 218) {
1155 return 51128307;
1156 } else {
1157 return 52063748;
1158 }
1159 }
1160 } else {
1161 if (level <= 221) {
1162 if (level <= 220) {
1163 return 53016304;
1164 } else {
1165 return 53986287;
1166 }
1167 } else {
1168 if (level <= 222) {
1169 return 54974018;
1170 } else {
1171 return 55979819;
1172 }
1173 }
1174 }
1175 }
1176 }
1177 } else {
1178 if (level <= 239) {
1179 if (level <= 231) {
1180 if (level <= 227) {
1181 if (level <= 225) {
1182 if (level <= 224) {
1183 return 57004023;
1184 } else {
1185 return 58046966;
1186 }
1187 } else {
1188 if (level <= 226) {
1189 return 59108990;
1190 } else {
1191 return 60190445;
1192 }
1193 }
1194 } else {
1195 if (level <= 229) {
1196 if (level <= 228) {
1197 return 61291686;
1198 } else {
1199 return 62413076;
1200 }
1201 } else {
1202 if (level <= 230) {
1203 return 63554982;
1204 } else {
1205 return 64717781;
1206 }
1207 }
1208 }
1209 } else {
1210 if (level <= 235) {
1211 if (level <= 233) {
1212 if (level <= 232) {
1213 return 65901854;
1214 } else {
1215 return 67107591;
1216 }
1217 } else {
1218 if (level <= 234) {
1219 return 68335388;
1220 } else {
1221 return 69585649;
1222 }
1223 }
1224 } else {
1225 if (level <= 237) {
1226 if (level <= 236) {
1227 return 70858784;
1228 } else {
1229 return 72155213;
1230 }
1231 } else {
1232 if (level <= 238) {
1233 return 73475361;
1234 } else {
1235 return 74819663;
1236 }
1237 }
1238 }
1239 }
1240 } else {
1241 if (level <= 247) {
1242 if (level <= 243) {
1243 if (level <= 241) {
1244 if (level <= 240) {
1245 return 76188559;
1246 } else {
1247 return 77582501;
1248 }
1249 } else {
1250 if (level <= 242) {
1251 return 79001947;
1252 } else {
1253 return 80447362;
1254 }
1255 }
1256 } else {
1257 if (level <= 245) {
1258 if (level <= 244) {
1259 return 81919223;
1260 } else {
1261 return 83418013;
1262 }
1263 } else {
1264 if (level <= 246) {
1265 return 84944224;
1266 } else {
1267 return 86498360;
1268 }
1269 }
1270 }
1271 } else {
1272 if (level <= 251) {
1273 if (level <= 249) {
1274 if (level <= 248) {
1275 return 88080929;
1276 } else {
1277 return 89692453;
1278 }
1279 } else {
1280 if (level <= 250) {
1281 return 91333462;
1282 } else {
1283 return 93004494;
1284 }
1285 }
1286 } else {
1287 if (level <= 253) {
1288 if (level <= 252) {
1289 return 94706100;
1290 } else {
1291 return 96438837;
1292 }
1293 } else {
1294 if (level <= 254) {
1295 return 98203277;
1296 } else {
1297 return 100000000;
1298 }
1299 }
1300 }
1301 }
1302 }
1303 }
1304 }
1305 }
1306 }
1307}
1308