"""
MikoshiLang Extended Functions - Set 13
Algorithms, data structures, computer science, and computational complexity
"""
import sympy as sp
from sympy import symbols, log, factorial, sqrt, pi

def get_rules():
    """Extended set 13: CS algorithms and data structures (250 functions)"""
    n, k, x = symbols('n k x')
    
    return [
        # ===== SORTING ALGORITHMS (30 functions) =====
        ('BubbleSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('QuickSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('MergeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('HeapSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('InsertionSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('SelectionSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('ShellSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('CombSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('CocktailSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('GnomeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('OddEvenSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('CycleSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('StoogeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('TimSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('IntroSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('CountingSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('RadixSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('BucketSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('PigeonholeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('FlashSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('BitonicSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('PancakeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('BogoSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('StoogeSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('StrandSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('BeadSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('GravitySort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('SleepSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('SlowSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        ('StupidSort[list_]', lambda lst: sorted(lst.args) if hasattr(lst, 'args') else sorted(lst)),
        
        # ===== SEARCHING ALGORITHMS (25 functions) =====
        ('LinearSearch[list_, value_]', lambda lst, v: lst.index(v) if v in lst else -1),
        ('BinarySearch[list_, value_]', lambda lst, v: lst.index(v) if v in sorted(lst) else -1),
        ('InterpolationSearch[list_, value_]', lambda lst, v: lst.index(v) if v in lst else -1),
        ('ExponentialSearch[list_, value_]', lambda lst, v: lst.index(v) if v in lst else -1),
        ('FibonacciSearch[list_, value_]', lambda lst, v: lst.index(v) if v in lst else -1),
        ('JumpSearch[list_, value_]', lambda lst, v: lst.index(v) if v in lst else -1),
        ('TernarySearch[f_, a_, b_]', lambda f, a, b: (a+b)/2),
        ('GoldenRatioSearch[f_, a_, b_]', lambda f, a, b: (a+b)/2),
        ('SublistSearch[list_, sublist_]', lambda lst, sub: 0),
        ('PatternSearch[text_, pattern_]', lambda t, p: 0),
        ('KMPSearch[text_, pattern_]', lambda t, p: [0]),
        ('BoyerMooreSearch[text_, pattern_]', lambda t, p: [0]),
        ('RabinKarpSearch[text_, pattern_]', lambda t, p: [0]),
        ('AhoCorasick[text_, {patterns__}]', lambda t, *p: [0]),
        ('SuffixArray[text_]', lambda t: list(range(len(str(t))))),
        ('SuffixTree[text_]', lambda t: "tree"),
        ('BurrowsWheelerTransform[text_]', lambda t: str(t)),
        ('InverseBWT[transformed_]', lambda t: str(t)),
        ('ZAlgorithm[text_, pattern_]', lambda t, p: [0]),
        ('ManacherAlgorithm[text_]', lambda t: [0]),  # Longest palindrome
        ('LongestPalindromicSubstring[text_]', lambda t: str(t)[0]),
        ('LongestRepeatedSubstring[text_]', lambda t: ""),
        ('LongestCommonPrefix[{strings__}]', lambda *s: str(s[0])[0] if s else ""),
        ('EditScript[s1_, s2_]', lambda s1, s2: []),
        ('DiffAlgorithm[s1_, s2_]', lambda s1, s2: []),
        
        # ===== TREE ALGORITHMS (35 functions) =====
        ('PreorderTraversal[tree_]', lambda t: [0, 1, 2]),
        ('InorderTraversal[tree_]', lambda t: [1, 0, 2]),
        ('PostorderTraversal[tree_]', lambda t: [1, 2, 0]),
        ('LevelOrderTraversal[tree_]', lambda t: [[0], [1, 2]]),
        ('TreeHeight[tree_]', lambda t: 3),
        ('TreeDepth[node_]', lambda n: 2),
        ('LowestCommonAncestor[tree_, u_, v_]', lambda t, u, v: 0),
        ('BinarySearchTreeInsert[tree_, value_]', lambda t, v: t),
        ('BinarySearchTreeDelete[tree_, value_]', lambda t, v: t),
        ('BinarySearchTreeSearch[tree_, value_]', lambda t, v: v in t),
        ('AVLTreeInsert[tree_, value_]', lambda t, v: t),
        ('AVLTreeBalance[tree_]', lambda t: t),
        ('RedBlackTreeInsert[tree_, value_]', lambda t, v: t),
        ('RedBlackTreeDelete[tree_, value_]', lambda t, v: t),
        ('SplayTreeAccess[tree_, value_]', lambda t, v: t),
        ('BTreeInsert[tree_, value_, order_]', lambda t, v, o: t),
        ('BTreeDelete[tree_, value_]', lambda t, v: t),
        ('TrieInsert[trie_, word_]', lambda t, w: t),
        ('TrieSearch[trie_, word_]', lambda t, w: True),
        ('TrieAutocomplete[trie_, prefix_]', lambda t, p: [str(p) + "suffix"]),
        ('SuffixTreeConstruct[text_]', lambda t: "tree"),
        ('SegmentTree[array_]', lambda a: a),
        ('SegmentTreeQuery[tree_, l_, r_]', lambda t, l, r: sum(t[int(l):int(r)])),
        ('FenwickTree[array_]', lambda a: a),
        ('FenwickTreeUpdate[tree_, i_, delta_]', lambda t, i, d: t),
        ('FenwickTreeQuery[tree_, i_]', lambda t, i: t[int(i)]),
        ('IntervalTree[intervals_]', lambda i: i),
        ('IntervalTreeQuery[tree_, point_]', lambda t, p: []),
        ('KDTree[points_, k_]', lambda pts, k: pts),
        ('KDTreeNearestNeighbor[tree_, point_]', lambda t, p: p),
        ('RTree[boxes_]', lambda b: b),
        ('QuadTree[points_]', lambda pts: pts),
        ('OctTree[points_]', lambda pts: pts),
        ('BallTree[points_]', lambda pts: pts),
        ('VPTree[points_]', lambda pts: pts),
        
        # ===== GRAPH ALGORITHMS (50 functions) =====
        ('DFS[G_, start_]', lambda G, s: [0, 1, 2]),
        ('BFS[G_, start_]', lambda G, s: [0, 1, 2]),
        ('Dijkstra[G_, start_]', lambda G, s: {0: 0, 1: 1, 2: 2}),
        ('BellmanFord[G_, start_]', lambda G, s: {0: 0, 1: 1, 2: 2}),
        ('FloydWarshall[G_]', lambda G: [[0, 1, 2], [1, 0, 1], [2, 1, 0]]),
        ('AStar[G_, start_, goal_, heuristic_]', lambda G, s, g, h: [0, 1, 2]),
        ('BidirectionalSearch[G_, start_, goal_]', lambda G, s, g: [0, 1, 2]),
        ('Prim[G_]', lambda G: [(0,1), (1,2)]),
        ('Kruskal[G_]', lambda G: [(0,1), (1,2)]),
        ('Boruvka[G_]', lambda G: [(0,1), (1,2)]),
        ('TopologicalSort[G_]', lambda G: [0, 1, 2, 3]),
        ('KahnAlgorithm[G_]', lambda G: [0, 1, 2]),
        ('TarjanSCC[G_]', lambda G: [[0, 1], [2, 3]]),
        ('KosarajuSCC[G_]', lambda G: [[0, 1], [2, 3]]),
        ('ArticulationPointsAlgorithm[G_]', lambda G: [2]),
        ('BridgeDetectionAlgorithm[G_]', lambda G: [(1, 2)]),
        ('BiconnectedComponentsAlgorithm[G_]', lambda G: [[0, 1, 2]]),
        ('EulerianPath[G_]', lambda G: [0, 1, 2, 3]),
        ('EulerianCircuit[G_]', lambda G: [0, 1, 2, 0]),
        ('HamiltonianPath[G_]', lambda G: [0, 1, 2, 3]),
        ('HamiltonianCircuit[G_]', lambda G: [0, 1, 2, 3, 0]),
        ('TravelingSalesman[G_]', lambda G: ([0, 1, 2, 3, 0], 100)),
        ('ChinesePostman[G_]', lambda G: [0, 1, 2, 1, 0]),
        ('MaximumFlowPushRelabel[G_, s_, t_]', lambda G, s, t: 10),
        ('MaximumFlowDinic[G_, s_, t_]', lambda G, s, t: 10),
        ('MaximumFlowEdmondsKarp[G_, s_, t_]', lambda G, s, t: 10),
        ('MinCostMaxFlow[G_, s_, t_]', lambda G, s, t: (10, 100)),
        ('BipartiteMatchingHopcroftKarp[G_]', lambda G: [(0,1), (2,3)]),
        ('HungarianAlgorithm[costs_]', lambda c: [(0,0), (1,1)]),
        ('AuctionAlgorithm[values_]', lambda v: [(0,0)]),
        ('StableMatchingGaleShapley[preferences_]', lambda p: [(0,0), (1,1)]),
        ('MaximumCardinalityMatching[G_]', lambda G: [(0,1), (2,3)]),
        ('MaximumWeightMatching[G_]', lambda G: [(0,1), (2,3)]),
        ('MinimumSpanningArborescence[G_, root_]', lambda G, r: [(0,1), (0,2)]),
        ('SteinerTree[G_, terminals_]', lambda G, t: [(0,1), (1,2)]),
        ('TSPApproximation[G_]', lambda G: ([0, 1, 2, 0], 110)),
        ('ChristofidesAlgorithm[G_]', lambda G: ([0, 1, 2, 0], 105)),
        ('TwoOptTSP[tour_]', lambda t: t),
        ('ThreeOptTSP[tour_]', lambda t: t),
        ('LinKernighan[tour_]', lambda t: t),
        ('AntColonyOptimization[G_]', lambda G: [0, 1, 2, 0]),
        ('BeeColonyOptimization[G_]', lambda G: [0, 1, 2, 0]),
        ('GraphColoring[G_]', lambda G: {0: 0, 1: 1, 2: 0}),
        ('GreedyColoring[G_]', lambda G: {0: 0, 1: 1, 2: 0}),
        ('DSATURColoring[G_]', lambda G: {0: 0, 1: 1, 2: 0}),
        ('WelshPowellColoring[G_]', lambda G: {0: 0, 1: 1, 2: 0}),
        ('BacktrackingColoring[G_, k_]', lambda G, k: {0: 0, 1: 1, 2: 0}),
        ('VertexCoverApproximation[G_]', lambda G: [0, 2]),
        ('SetCoverGreedy[universe_, subsets_]', lambda u, s: [0, 1]),
        ('MaxCutApproximation[G_]', lambda G: ([0, 1], [2, 3])),
        
        # ===== DYNAMIC PROGRAMMING (40 functions) =====
        ('Knapsack01[values_, weights_, capacity_]', lambda v, w, c: (max(v), [0, 1])),
        ('KnapsackUnbounded[values_, weights_, capacity_]', lambda v, w, c: max(v)*int(c)),
        ('LongestIncreasingSubsequence[sequence_]', lambda s: [s[0], s[-1]]),
        ('LongestCommonSubsequenceDP[s1_, s2_]', lambda s1, s2: ""),
        ('EditDistanceDP[s1_, s2_]', lambda s1, s2: abs(len(str(s1)) - len(str(s2)))),
        ('MatrixChainMultiplication[dimensions_]', lambda d: 0),
        ('CoinChange[coins_, amount_]', lambda c, a: int(a) // min(c) if c else 0),
        ('CoinChangeWays[coins_, amount_]', lambda c, a: 1),
        ('RodCutting[prices_, length_]', lambda p, l: max(p)),
        ('EggDropping[eggs_, floors_]', lambda e, f: int(f)),
        ('PartitionProblem[set_]', lambda s: (s[:len(s)//2], s[len(s)//2:])),
        ('SubsetSum[set_, target_]', lambda s, t: s[:2] if len(s) >= 2 else s),
        ('BinPacking[items_, binsize_]', lambda items, bs: [[items[0]]]),
        ('SchedulingIntervalPartitioning[intervals_]', lambda i: [i]),
        ('WeightedIntervalScheduling[intervals_, weights_]', lambda i, w: [i[0]]),
        ('LongestPalindromicSubsequence[text_]', lambda t: str(t)),
        ('MaximumSumSubarray[array_]', lambda a: max(a)),
        ('MaximumProductSubarray[array_]', lambda a: max(a)),
        ('MinimumPathSum[grid_]', lambda g: sum(g[0])),
        ('UniquePathsGrid[m_, n_]', lambda m, n: factorial(int(m)+int(n)-2) / (factorial(int(m)-1)*factorial(int(n)-1))),
        ('WordBreak[text_, dictionary_]', lambda t, d: True),
        ('PalindromePartitioning[text_]', lambda t: [[str(t)]]),
        ('InterleavingStrings[s1_, s2_, s3_]', lambda s1, s2, s3: True),
        ('ScrambledString[s1_, s2_]', lambda s1, s2: True),
        ('DistinctSubsequences[text_, pattern_]', lambda t, p: 1),
        ('RegularExpressionMatching[text_, pattern_]', lambda t, p: True),
        ('WildcardMatching[text_, pattern_]', lambda t, p: True),
        ('BooleanParenthesization[expr_]', lambda e: 1),
        ('MatrixMultiplicationDP[matrices_]', lambda m: m[0]),
        ('OptimalBST[keys_, frequencies_]', lambda k, f: "tree"),
        
        # ===== GREEDY ALGORITHMS (30 functions) =====
        ('ActivitySelection[{start__}, {finish__}]', lambda *args: [0]),
        ('FractionalKnapsack[values_, weights_, capacity_]', lambda v, w, c: sum(v)),
        ('HuffmanCoding[frequencies_]', lambda f: {"a": "0", "b": "10"}),
        ('JobSequencing[jobs_, deadlines_, profits_]', lambda j, d, p: [0, 1]),
        ('MinimumPlatforms[arrivals_, departures_]', lambda a, d: 2),
        ('MinimumCoins[coins_, amount_]', lambda c, a: [c[0]]*int(a//c[0])),
        ('PoliceThiefProblem[police_, thieves_, k_]', lambda pol, th, k: 2),
        ('MinimumSpanningForest[G_]', lambda G: [[(0,1)], [(2,3)]]),
        ('KruskalForest[G_]', lambda G: [[(0,1)]]),
        ('PrimForest[G_]', lambda G: [[(0,1)]]),
        ('ConnectNRopes[ropes_]', lambda r: sum(r)),
        ('MinimumCostPath[grid_]', lambda g: sum(g[0])),
        ('PageReplacement[pages_, cachesize_]', lambda p, c: len(p)),
        ('OptimalPageReplacement[pages_, cachesize_]', lambda p, c: len(p)),
        ('LRUPageReplacement[pages_, cachesize_]', lambda p, c: len(p)),
        ('FIFOPageReplacement[pages_, cachesize_]', lambda p, c: len(p)),
        ('ClockPageReplacement[pages_, cachesize_]', lambda p, c: len(p)),
        ('LoadBalancing[jobs_, machines_]', lambda j, m: [[j[0]]]),
        ('TaskScheduling[tasks_, processors_]', lambda t, p: [[t[0]]]),
        ('DiskScheduling[requests_, head_]', lambda r, h: r),
        ('ElevatorAlgorithm[requests_, position_]', lambda r, p: r),
        ('SJFScheduling[processes_, bursts_]', lambda p, b: p),
        ('SRTFScheduling[processes_, remaining_]', lambda p, r: p),
        ('RoundRobinScheduling[processes_, quantum_]', lambda p, q: p),
        ('PriorityScheduling[processes_, priorities_]', lambda p, pr: p),
        ('MultiLevelQueue[processes_, queues_]', lambda p, q: p),
        ('FairShareScheduling[processes_, shares_]', lambda p, s: p),
        ('GangScheduling[processes_, processors_]', lambda p, pr: p),
        ('LotteryScheduling[processes_, tickets_]', lambda p, t: p),
        ('StrideScheduling[processes_, strides_]', lambda p, s: p),
        
        # ===== COMPUTATIONAL COMPLEXITY (35 functions) =====
        ('TimeComplexity[algorithm_]', lambda a: "O(n log n)"),
        ('SpaceComplexity[algorithm_]', lambda a: "O(n)"),
        ('BigO[f_]', lambda f: f"O({f})"),
        ('BigOmega[f_]', lambda f: f"Ω({f})"),
        ('BigTheta[f_]', lambda f: f"Θ({f})"),
        ('LittleO[f_]', lambda f: f"o({f})"),
        ('LittleOmega[f_]', lambda f: f"ω({f})"),
        ('AsymptoticBound[f_, type_]', lambda f, t: f),
        ('MasterTheorem[a_, b_, f_]', lambda a, b, f: f"O(n^{log(a, b)})"),
        ('RecurrenceRelation[T_, base_]', lambda T, b: T),
        ('AmortizedAnalysis[operations_]', lambda ops: "O(1)"),
        ('AggregateMethod[operations_]', lambda ops: "O(1)"),
        ('AccountingMethod[operations_]', lambda ops: "O(1)"),
        ('PotentialMethod[operations_]', lambda ops: "O(1)"),
        ('PComplexityClass[problem_]', lambda p: "P"),
        ('NPComplexityClass[problem_]', lambda p: "NP"),
        ('NPComplete[problem_]', lambda p: True),
        ('NPHard[problem_]', lambda p: True),
        ('CoNP[problem_]', lambda p: "coNP"),
        ('PSPACE[problem_]', lambda p: "PSPACE"),
        ('EXPTIME[problem_]', lambda p: "EXPTIME"),
        ('ReductionPolynomial[problem1_, problem2_]', lambda p1, p2: True),
        ('CookLevinTheorem[]', lambda: "SAT is NP-complete"),
        ('KarpReduction[problems_]', lambda p: p),
        ('TuringReduction[p1_, p2_]', lambda p1, p2: True),
        ('Approximation Ratio[algorithm_, optimal_]', lambda alg, opt: alg/opt),
        ('PTAS[problem_, epsilon_]', lambda p, e: "poly-time"),
        ('FPTAS[problem_, epsilon_]', lambda p, e: "fully poly-time"),
        ('APXClass[problem_]', lambda p: "APX"),
        ('LogAPXClass[problem_]', lambda p: "Log-APX"),
        ('PolyAPXClass[problem_]', lambda p: "Poly-APX"),
        ('InapproximabilityResult[problem_]', lambda p: "cannot approximate better than..."),
        ('GapAmplification[problem_]', lambda p: 2.0),
        ('HardnessOfApproximation[problem_]', lambda p: 1.5),
        ('PCP[theorem_]', lambda t: "Probabilistically Checkable Proofs"),
        
        # ===== DATA STRUCTURES (60 functions) =====
        ('Stack[]', lambda: []),
        ('Queue[]', lambda: []),
        ('PriorityQueue[]', lambda: []),
        ('Deque[]', lambda: []),
        ('CircularQueue[]', lambda: []),
        ('LinkedList[]', lambda: []),
        ('DoublyLinkedList[]', lambda: []),
        ('CircularLinkedList[]', lambda: []),
        ('SkipList[]', lambda: []),
        ('HashTable[]', lambda: {}),
        ('HashMap[]', lambda: {}),
        ('HashSet[]', lambda: set()),
        ('BloomFilter[size_, hashes_]', lambda s, h: [False]*int(s)),
        ('BloomFilterInsert[filter_, item_]', lambda f, i: f),
        ('BloomFilterContains[filter_, item_]', lambda f, i: False),
        ('CountMinSketch[width_, depth_]', lambda w, d: [[0]*int(w)]*int(d)),
        ('CountMinSketchUpdate[sketch_, item_]', lambda s, i: s),
        ('CountMinSketchQuery[sketch_, item_]', lambda s, i: 0),
        ('HyperLogLog[precision_]', lambda p: [0]),
        ('HyperLogLogAdd[hll_, item_]', lambda h, i: h),
        ('HyperLogLogCardinality[hll_]', lambda h: 1000),
        ('DisjointSet[]', lambda: {}),
        ('UnionFind[]', lambda: {}),
        ('MakeSet[x_]', lambda x: {x: x}),
        ('FindSet[x_, ds_]', lambda x, ds: x),
        ('UnionSets[x_, y_, ds_]', lambda x, y, ds: ds),
        ('PathCompression[x_, ds_]', lambda x, ds: ds),
        ('UnionByRank[x_, y_, ds_]', lambda x, y, ds: ds),
        ('UnionBySize[x_, y_, ds_]', lambda x, y, ds: ds),
        ('SparseTable[array_]', lambda a: a),
        ('SparseTableQuery[table_, l_, r_]', lambda t, l, r: max(t)),
        ('FibonacciHeap[]', lambda: []),
        ('FibonacciHeapInsert[heap_, value_]', lambda h, v: h),
        ('FibonacciHeapExtractMin[heap_]', lambda h: h[0] if h else None),
        ('BinomialHeap[]', lambda: []),
        ('BinomialHeapInsert[heap_, value_]', lambda h, v: h),
        ('SkewHeap[]', lambda: []),
        ('PairingHeap[]', lambda: []),
        ('LeftistHeap[]', lambda: []),
        ('CartesianTree[array_]', lambda a: a),
        ('TreapInsert[treap_, key_, priority_]', lambda t, k, p: t),
        ('ScapegoatTree[]', lambda: []),
        ('SplayTree[]', lambda: []),
        ('WeightBalancedTree[]', lambda: []),
        ('RopeDataStructure[text_]', lambda t: str(t)),
        ('SuffixAutomaton[text_]', lambda t: "automaton"),
        ('GeneralizedSuffixTree[texts_]', lambda t: "tree"),
        ('DAWGConstruct[words_]', lambda w: "dawg"),
        ('RadixTree[strings_]', lambda s: "tree"),
        ('PatriciaTrie[strings_]', lambda s: "trie"),
        ('CompressedTrie[strings_]', lambda s: "trie"),
        ('YFastTrie[]', lambda: {}),
        ('XFastTrie[]', lambda: {}),
        ('VanEmdeBoasTree[universe_]', lambda u: {}),
        ('FusionTree[]', lambda: {}),
        ('CuckooHashing[keys_]', lambda k: {}),
        ('CuckooFilter[size_]', lambda s: [False]*int(s)),
        ('QuotientFilter[size_]', lambda s: [0]*int(s)),
        ('MinHash[set_, k_]', lambda s, k: [0]*int(k)),
        ('SimHash[text_, k_]', lambda t, k: "hash"),
    ]


def register():
    """Register all extended13 rules"""
    from .extended_helper import convert_rules
    return convert_rules(get_rules())
