effspm 0.2.6__cp310-cp310-win_amd64.whl → 0.3.0__cp310-cp310-win_amd64.whl

effspm/largepp/src/freq_miner.cpp

@@ -1,170 +1,198 @@
+#include <algorithm>
+#include <cstdlib>
+#include <fstream>
 #include <iostream>
-#include <time.h>
+
 #include "freq_miner.hpp"
+#include "pattern.hpp"
+#include "load_inst.hpp"
 #include "utility.hpp"
 
-namespace largepp   // ← BEGIN namespacing
-{
-void Out_patt(vector<int>& seq, unsigned int freq);
-void Extend_patt(Pattern& _patt);
-
-unsigned long long int num_patt = 0;
-
-Pattern _patt;
+namespace largepp {
 
-void Freq_miner() {
+using std::abs;
+using std::cout;
+using std::endl;
+using std::ofstream;
+using std::swap;
+using std::vector;
 
-	vector<int> islist;
+static void Out_patt(vector<int>& seq, unsigned int freq);
+static void Extend_patt(Pattern& _pattern);
 
-	for (int i = 0; i < L; ++i) {
-		if (DFS[i].freq >= theta) 
-			islist.push_back(i);
-	}
-
-	for (int i = 0; i < DFS.size(); ++i) {
-		DFS[i].ilist = islist;
-		DFS[i].slist = islist;
-	}
-	
-	while (!DFS.empty() && give_time(clock() - start_time) < time_limit) {
-		if (DFS.back().freq >= theta)
-			Extend_patt(DFS.back());
-		else 
-			DFS.pop_back();
-	}
+unsigned long long int num_patt = 0;      // counter for emitted patterns
+static Pattern _patt;                     // scratch pattern (for in-place extend)
 
+/* ------------------------------------------------------------------ */
+/*  Driver                                                            */
+/* ------------------------------------------------------------------ */
+void Freq_miner()
+{
+    // Build the candidate item list once (items that pass minsup at length-1)
+    vector<int> islist;
+    islist.reserve(L);
+    for (unsigned int i = 0; i < L; ++i) {
+        if (DFS[i].freq >= theta) islist.push_back(static_cast<int>(i));
+    }
+
+    // Seed each 1-length pattern’s extension lists
+    for (unsigned int i = 0; i < DFS.size(); ++i) {
+        DFS[i].ilist = islist;
+        DFS[i].slist = islist;
+    }
+
+    // DFS over the stack, extending only nodes whose current support ≥ theta
+    while (!DFS.empty() && give_time(std::clock() - start_time) < time_limit) {
+        if (DFS.back().freq >= theta) {
+            Extend_patt(DFS.back());
+        } else {
+            DFS.pop_back();
+        }
+    }
 }
 
-void Extend_patt(Pattern& _pattern) {
-
-	swap(_patt, _pattern);
-	DFS.pop_back();
-
-	vector<bool> slist(L, 0);
-	vector<bool> ilist(L, 0);
-	
-	for (vector<int>::iterator it = _patt.slist.begin(); it != _patt.slist.end(); ++it)
-		slist[*it] = 1;
-	for (vector<int>::iterator it = _patt.ilist.begin(); it != _patt.ilist.end(); ++it)
-		ilist[*it] = 1;
-
-	vector<Pattern> pot_patt(L * 2);
-
-	int last_neg = _patt.seq.size() - 1;
-	while (_patt.seq[last_neg] > 0)
-		--last_neg;
-
-	for (int i = 0; i < _patt.str_pnt.size(); ++i) {
-
-		vector<bool> found(L * 2, 0);		
-
-		unsigned long long int seq = _patt.seq_ID[i];				
-		unsigned int j = _patt.str_pnt[i] + 1;
-		while (j < items[seq].size() && items[seq][j] > 0) {
-			int cur_itm = items[seq][j];
-			if (ilist[cur_itm - 1]) {
-				pot_patt[cur_itm - 1].seq_ID.push_back(seq);
-				pot_patt[cur_itm - 1].str_pnt.push_back(j);
-				++pot_patt[cur_itm - 1].freq;
-				found[cur_itm - 1] = 1;
-			}
-			++j;
-		}
-		
-		int num_itmfnd = 0;
-		for (int k = j; k < items[seq].size(); ++k) {
-			int cur_itm = abs(items[seq][k]);
-			if (items[seq][k] < 0) 
-				num_itmfnd = 0;
-			if (slist[cur_itm - 1] && !found[L + cur_itm - 1]) {
-				pot_patt[L + cur_itm - 1].seq_ID.push_back(seq);
-				pot_patt[L + cur_itm - 1].str_pnt.push_back(k);
-				++pot_patt[L + cur_itm - 1].freq;
-				found[L + cur_itm - 1] = 1;
-			}
-			if (num_itmfnd == _patt.seq.size() - last_neg) {
-				if (ilist[cur_itm - 1] && !found[cur_itm - 1]) {
-					pot_patt[cur_itm - 1].seq_ID.push_back(seq);
-					pot_patt[cur_itm - 1].str_pnt.push_back(k);
-					++pot_patt[cur_itm - 1].freq;
-					found[cur_itm - 1] = 1;
-				}
-			}
-			else if (cur_itm == abs(_patt.seq[last_neg + num_itmfnd])) 
-				++num_itmfnd;
-		}
-	}
-
-
-	vector<int> slistp;
-	vector<int> ilistp;
-
-	for (vector<int>::iterator it = _patt.ilist.begin(); it != _patt.ilist.end(); ++it) {
-		if (pot_patt[*it].freq >= theta) 
-			ilistp.push_back(*it);
-	}
-
-	for (vector<int>::iterator it = _patt.slist.begin(); it != _patt.slist.end(); ++it) {
-		if (pot_patt[(*it) + L].freq >= theta) 
-			slistp.push_back(*it);
-	}
-
-	for (vector<int>::iterator it = ilistp.begin(); it != ilistp.end(); ++it) {
-		DFS.emplace_back();
-		swap(DFS.back(), pot_patt[*it]);
-		DFS.back().seq = _patt.seq;
-		DFS.back().seq.push_back((*it) + 1);
-		DFS.back().slist = slistp;
-		DFS.back().ilist = ilistp;
-		if (b_disp || b_write) 
-			Out_patt(DFS.back().seq, DFS.back().freq);
-		++num_patt;
-	}
-
-
-	for (vector<int>::iterator it = slistp.begin(); it != slistp.end(); ++it) {
-		DFS.emplace_back();
-		swap(DFS.back(), pot_patt[(*it) + L]);
-		DFS.back().seq = _patt.seq;
-		DFS.back().seq.push_back(-(*it) - 1);
-		DFS.back().slist = slistp;
-		DFS.back().ilist = slistp;
-		if (b_disp || b_write) 
-			Out_patt(DFS.back().seq, DFS.back().freq);
-		++num_patt;
-	}
-
+/* ------------------------------------------------------------------ */
+/*  Extend_patt: given a frequent pattern, enumerate its i- and s-ext */
+/* ------------------------------------------------------------------ */
+static void Extend_patt(Pattern& _pattern)
+{
+    swap(_patt, _pattern);  // work on local scratch
+    DFS.pop_back();         // remove from stack
+
+    // Quick presence tables for allowed i-/s-extensions
+    vector<bool> slist(L, false);
+    vector<bool> ilist(L, false);
+    for (int idx : _patt.slist) slist[static_cast<size_t>(idx)] = true;
+    for (int idx : _patt.ilist) ilist[static_cast<size_t>(idx)] = true;
+
+    // Potential children buffers:
+    vector<Pattern> pot_patt(L * 2); // [0..L-1] = i-ext, [L..2L-1] = s-ext
+
+    // Find last negative from the end (boundary between itemsets)
+    int last_neg = static_cast<int>(_patt.seq.size()) - 1;
+    while (last_neg >= 0 && _patt.seq[static_cast<size_t>(last_neg)] > 0) --last_neg;
+
+    // Scan occurrences to build supports for all valid next-steps
+    for (size_t i = 0; i < _patt.str_pnt.size(); ++i) {
+        vector<bool> found(L * 2, false);
+
+        unsigned long long seq_id = _patt.seq_ID[i];
+        unsigned int j = _patt.str_pnt[i] + 1;
+
+        // 1) Same itemset (i-extension) forward until end-of-itemset (>0)
+        while (j < items[seq_id].size() && items[seq_id][j] > 0) {
+            int cur_itm = items[seq_id][j];
+            if (ilist[static_cast<size_t>(cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(j);
+                ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                found[static_cast<size_t>(cur_itm - 1)] = true;
+            }
+            ++j;
+        }
+
+        // 2) Later itemsets (s-extension), plus special re-open i-ext rule
+        int num_itmfnd = 0;
+        for (size_t k = j; k < items[seq_id].size(); ++k) {
+            int cur = items[seq_id][k];
+            int cur_itm = abs(cur);
+
+            if (cur < 0) num_itmfnd = 0; // new itemset boundary seen
+
+            // s-extension: add cur_itm as new itemset element
+            if (slist[static_cast<size_t>(cur_itm - 1)] &&
+                !found[static_cast<size_t>(L + cur_itm - 1)]) {
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].seq_ID.push_back(seq_id);
+                pot_patt[static_cast<size_t>(L + cur_itm - 1)].str_pnt.push_back(k);
+                ++pot_patt[static_cast<size_t>(L + cur_itm - 1)].freq;
+                found[static_cast<size_t>(L + cur_itm - 1)] = true;
+            }
+
+            // once we've seen the suffix of the last itemset fully,
+            // allow i-extension again (across future itemsets)
+            if (num_itmfnd == static_cast<int>(_patt.seq.size()) - last_neg) {
+                if (ilist[static_cast<size_t>(cur_itm - 1)] &&
+                    !found[static_cast<size_t>(cur_itm - 1)]) {
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].seq_ID.push_back(seq_id);
+                    pot_patt[static_cast<size_t>(cur_itm - 1)].str_pnt.push_back(k);
+                    ++pot_patt[static_cast<size_t>(cur_itm - 1)].freq;
+                    found[static_cast<size_t>(cur_itm - 1)] = true;
+                }
+            } else if (last_neg + num_itmfnd >= 0 &&
+                       cur_itm == abs(_patt.seq[static_cast<size_t>(last_neg + num_itmfnd)])) {
+                ++num_itmfnd;
+            }
+        }
+    }
+
+    // Filter children by support threshold
+    vector<int> ilistp;
+    vector<int> slistp;
+    ilistp.reserve(_patt.ilist.size());
+    slistp.reserve(_patt.slist.size());
+
+    for (int idx : _patt.ilist) {
+        if (pot_patt[static_cast<size_t>(idx)].freq >= theta)
+            ilistp.push_back(idx);
+    }
+    for (int idx : _patt.slist) {
+        if (pot_patt[static_cast<size_t>(idx + static_cast<int>(L))].freq >= theta)
+            slistp.push_back(idx);
+    }
+
+    // Push all i-extensions
+    for (int idx : ilistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx)]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(idx + 1);
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = ilistp;
+
+        // ALWAYS emit (so collected fills even if !b_disp && !b_write)
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
+
+    // Push all s-extensions
+    for (int idx : slistp) {
+        DFS.emplace_back();
+        swap(DFS.back(), pot_patt[static_cast<size_t>(idx + static_cast<int>(L))]);
+
+        DFS.back().seq = _patt.seq;
+        DFS.back().seq.push_back(-(idx + 1));  // negative encodes new itemset
+
+        DFS.back().slist = slistp;
+        DFS.back().ilist = slistp;             // as in original code
+
+        // ALWAYS emit
+        Out_patt(DFS.back().seq, DFS.back().freq);
+        ++num_patt;
+    }
 }
 
-
-void Out_patt(vector<int>& seq, unsigned int freq) {
-
-	largepp::collected.push_back(seq);  
-
-	ofstream file_o;
-	if (b_write) 
-		file_o.open(out_file, std::ios::app);
-
-	for (int ii = 0; ii < seq.size(); ii++) {
-		if (b_disp)
-			cout << seq[ii] << " ";
-		if (b_write) 
-			file_o << seq[ii] << " ";
-	}
-	if (b_disp)
-		cout << endl;
-	if (b_write) 
-		file_o << endl;
-	
-	if (b_disp)
-		cout << "************** Freq: " << freq << endl;
-	if (b_write) {
-		file_o << "************** Freq: " << freq << endl;
-		file_o.close();
-	}
-}
+/* ------------------------------------------------------------------ */
+/*  Out_patt: append to buffer; optionally print/write                */
+/* ------------------------------------------------------------------ */
+static void Out_patt(vector<int>& seq, unsigned int freq)
+{
+    // Always append to in-memory results returned to Python
+    largepp::collected.push_back(seq);
+
+    ofstream file_o;
+    if (b_write) file_o.open(out_file, std::ios::app);
+
+    if (b_disp) {
+        for (int v : seq) cout << v << " ";
+        cout << "\n************** Freq: " << freq << endl;
+    }
+    if (b_write) {
+        for (int v : seq) file_o << v << " ";
+        file_o << "\n************** Freq: " << freq << "\n";
+        file_o.close();
+    }
 }
 
-
-
-
+} // namespace largepp

effspm/largepp/src/freq_miner.hpp

@@ -1,43 +1,18 @@
 #pragma once
 
-#include "load_inst.hpp"
-namespace largepp   // ← BEGIN namespacing
-{
-void Freq_miner();
-
-class Pattern {
-public:
-
-	vector<int> seq;
-	vector<unsigned int> str_pnt;
-	vector<unsigned long long int> seq_ID;
-
-	vector<int> slist;
-	vector<int> ilist;
-
-	unsigned long long int freq;
+#include <vector>
+#include <string>
 
-	Pattern(vector<int>& _seq, int item) {
-		seq.reserve(_seq.size());
-		for (int i = 0; i < _seq.size(); ++i)
-			seq.push_back(_seq[i]);
-		seq.push_back(item);
-		freq = 0;
-	}
+#include "pattern.hpp"   // defines largepp::Pattern
+#include "load_inst.hpp" // declares externs: items, L, theta, DFS, etc.
+#include "utility.hpp"   // flags, collected buffer, timers, helpers
 
+namespace largepp {
 
-	Pattern(int item) {
-		seq.push_back(item);
-		freq = 0;
-	}
-
-	Pattern() {
-		freq = 0;
-	}
-
-};
-
-extern vector<Pattern> DFS;				//DFS queue of potential patterns to extend
+// Public entry point
+void Freq_miner();
 
+// (defined in the .cpp)
 extern unsigned long long int num_patt;
-}
+
+} // namespace largepp

effspm/largepp/src/load_inst.cpp

@@ -2,6 +2,7 @@
 #include <sstream>
 #include <algorithm>
 #include <cmath>
+#include <fstream>
 #include "load_inst.hpp"
 #include "freq_miner.hpp"
 #include "utility.hpp"
@@ -36,6 +37,7 @@ bool Load_instance(string& items_file, double thresh)
 
         cout << "\nPreprocess done in " << give_time(clock() - kk) << " seconds\n\n";
 
+        DFS.clear();
         DFS.reserve(L);
         for (unsigned int i = 0; i < L; ++i)
             DFS.emplace_back(-int(i) - 1);
@@ -53,6 +55,23 @@ bool Load_instance(string& items_file, double thresh)
     cout << "Found " << N << " sequence, with max line len " << M
          << ", and " << L << " items, and " << E << " enteries\n";
 
+    // ───────────────────────────────────────────────────────────
+    // DEBUG snapshot of seeds right after loading
+    // ───────────────────────────────────────────────────────────
+    {
+        unsigned long long seeds_ge_theta = 0, seeds_nonzero = 0, max_freq = 0;
+        for (size_t i = 0; i < DFS.size(); ++i) {
+            if (DFS[i].freq > 0) ++seeds_nonzero;
+            if (DFS[i].freq >= theta) ++seeds_ge_theta;
+            if (DFS[i].freq > max_freq) max_freq = DFS[i].freq;
+        }
+       // std::cout << " theta=" << theta
+               //   << " | DFS.size=" << DFS.size()
+               //   << " | seeds>=theta=" << seeds_ge_theta
+              //    << " | seeds>0=" << seeds_nonzero
+              //    << " | max_seed_freq=" << max_freq << "\n";
+    }
+
     return true;
 }
 
@@ -67,12 +86,12 @@ void Load_py(const pybind11::object& data, double thresh)
     int max_id = 0;
     M = 0;  E = 0;
     for (auto& seq : items) {
-        M = max<unsigned int>(M, seq.size());
+        M = max<unsigned int>(M, static_cast<unsigned int>(seq.size()));
         E += seq.size();
         for (int x : seq)
             max_id = max(max_id, abs(x));
     }
-    L = max_id;
+    L = static_cast<unsigned int>(max_id);
     theta = (thresh < 1.0) ? ceil(thresh * N) : thresh;
 
     DFS.clear();
@@ -82,7 +101,7 @@ void Load_py(const pybind11::object& data, double thresh)
 }
 
 /* =================================================================
- *  The professor’s original helpers — untouched
+ *  The professor’s original helpers — untouched except minor safety
  * ================================================================= */
 static bool Preprocess(string& inst, double thresh)
 {
@@ -97,7 +116,7 @@ static bool Preprocess(string& inst, double thresh)
             string itm;
             while (word >> itm) {
                 ditem = stoi(itm);
-                L = max<unsigned int>(L, abs(ditem));
+                L = max<unsigned int>(L, static_cast<unsigned int>(abs(ditem)));
 
                 if (freq.size() < L) {
                     freq.resize(L, 0);
@@ -170,7 +189,7 @@ static void Load_items_pre(string& inst)
         }
         if (empty_seq) continue;
 
-        ++N;  E += size_m;  M = max<unsigned int>(M, size_m);
+        ++N;  E += size_m;  M = max<unsigned int>(M, static_cast<unsigned int>(size_m));
     }
 }
 
@@ -193,8 +212,8 @@ static bool Load_items(string& inst)
 
         while (word >> itm) {
             ditem = stoi(itm);
-            if (L < abs(ditem)) {
-                L = abs(ditem);
+            if (L < static_cast<unsigned int>(abs(ditem))) {
+                L = static_cast<unsigned int>(abs(ditem));
                 while (DFS.size() < L) {
                     DFS.emplace_back(-int(DFS.size()) - 1);
                     counted.push_back(0);
@@ -211,7 +230,7 @@ static bool Load_items(string& inst)
             ++size_m;
         }
         E += size_m;
-        M = max<unsigned int>(M, size_m);
+        M = max<unsigned int>(M, static_cast<unsigned int>(size_m));
     }
     return true;
 }

effspm/largepp/src/load_inst.hpp

@@ -6,23 +6,29 @@
 #include <map>
 #include <pybind11/pybind11.h>
 
+#include "largepp/src/pattern.hpp"   // ← ensure Pattern is a complete type here
+
 namespace largepp {
 using namespace std;
 
-// ───── public entry points ───────────────────────────────────────
-bool Load_instance(string& items_file, double thresh);
+// public entry points
+bool Load_instance(std::string& items_file, double thresh);
 void Load_py(const pybind11::object& py_data, double thresh);
 
-// ───── shared state (defined once in load_inst.cpp) ──────────────
-extern vector<vector<int>> items;      // encoded database
-extern string              out_file;
+// shared state (defined in load_inst.cpp)
+extern std::vector<std::vector<int>> items;
+extern std::string                    out_file;
 
 extern bool b_disp, b_write, use_dic, just_build, ovr_count, pre_pro;
+extern bool use_list;
 
 extern unsigned int        M, L, time_limit;
-extern unsigned long long  N;          // # sequences
-extern double              theta;      // support threshold
-extern unsigned long long  E;          // total entries
-extern clock_t             start_time;
+extern unsigned long long  N;
+extern double              theta;
+extern unsigned long long  E;
+extern std::clock_t        start_time;
+
+// DFS queue of potential patterns to extend
+extern std::vector<largepp::Pattern> DFS;
 
 } // namespace largepp

effspm/largepp/src/pattern.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include <vector>
+
+namespace largepp {
+
+class Pattern {
+public:
+    std::vector<int> seq;
+    std::vector<unsigned int> str_pnt;
+    std::vector<unsigned long long> seq_ID;
+
+    std::vector<int> slist;
+    std::vector<int> ilist;
+
+    unsigned long long freq;
+
+    Pattern() : freq(0) {}
+
+    explicit Pattern(int item) : freq(0) {
+        seq.push_back(item);
+    }
+
+    Pattern(std::vector<int>& _seq, int item) : freq(0) {
+        seq.reserve(_seq.size() + 1);
+        for (int i = 0; i < static_cast<int>(_seq.size()); ++i)
+            seq.push_back(_seq[i]);
+        seq.push_back(item);
+    }
+};
+
+} // namespace largepp

effspm/load_inst.hpp

@@ -11,7 +11,7 @@ using namespace std;
 
 // ------------------------------------------------------------
 // forward declare Pattern (defined in freq_miner.hpp)
-class Pattern;
+struct Pattern;
 
 
 // Main entrypoint: load your file on disk into 'items', build DFS, theta, etc.

{effspm-0.2.6.dist-info → effspm-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: effspm
-Version: 0.2.6
+Version: 0.3.0
 Summary: Prefix‑Projection and other sequential pattern mining algorithms
 Author: Yeswanth Vootla
 Author-email: yeshu999 <vootlayeswanth20@gmail.com>

effspm-0.3.0.dist-info/RECORD

@@ -0,0 +1,54 @@
+effspm/__init__.py,sha256=SRhZaFwKFWVneO_TCS9_ld5akH3rq3XtHcinJlAvjPw,257
+effspm/_core.cpp,sha256=JzUCIVmmDMVfRIjIsmXtVkSMkRMprE3wpOrx-jYhAQU,3781
+effspm/_effspm.cp310-win_amd64.pyd,sha256=95nMHGmYmACSINFzbnD2OOBoFnjL6t1M62XdAaY_zig,388096
+effspm/_effspm.cpp,sha256=iXMaevu3nN2p7jMJuf-IPDiGf7SZ7vlNXC8cga2pDU8,26021
+effspm/freq_miner.cpp,sha256=qQDFPoPKY3ICaH2brm1CUKwNBhCy0-0dUWEoV_3FwME,4785
+effspm/freq_miner.hpp,sha256=Ni4ayFci6zPnpwbLBQ6FU5MSvLjgn6jk2_GQ45HHtgo,835
+effspm/load_inst.cpp,sha256=kTEucQ5YU7xPdRjcM9ixAPk49cLJ8H8YN9gJsTrm7mM,4769
+effspm/load_inst.hpp,sha256=S8NvO3KCU6dGcDX8a24SE6uhD1cSAL0jCo0XYFnrwKE,938
+effspm/utility.cpp,sha256=OD5K0K0jQKgqVGJm91pSofImXOEVkDnqQvFh1qytvpA,1458
+effspm/utility.hpp,sha256=hECSm-ORd20QJMundbOLkZvo9nj-I2pXd5AokagyGqQ,773
+effspm/btminer/src/build_mdd.cpp,sha256=t4Exn5vJTekl5nyRg77p898pwjC9NxECAgL4DKgwpR4,2297
+effspm/btminer/src/build_mdd.hpp,sha256=3HDZdQ8k_sJR9UNPvO-48mdnjJGfFaE0vorp86DsQIU,661
+effspm/btminer/src/freq_miner.cpp,sha256=GjttxpUpJpvKugXcKJ2utKG6IeZKVEyiv2RI-nE9jM0,9456
+effspm/btminer/src/freq_miner.hpp,sha256=REbDhYzn7PG1XKjLqaMnk_PzUwwCQKiBGD0DPx3DBI4,1110
+effspm/btminer/src/load_inst.cpp,sha256=g_kdYl7tIavuVBEQ30BKh19tfY9cNCBc2BGnnqrK5ZE,8269
+effspm/btminer/src/load_inst.hpp,sha256=n47RjtvkBuBSb5OLxSuqvUQpPFd7ukMQTD0AIHiYIfw,1030
+effspm/btminer/src/utility.cpp,sha256=5at1rTDLS3Jw90tENm0V3W1fEc7q_HhtIG6TyrKYKgg,1244
+effspm/btminer/src/utility.hpp,sha256=ite_7AY33HJKZiFRENhQ3xjNmak5yKy_hE8Ku6-9q2Y,328
+effspm/htminer/src/build_mdd.cpp,sha256=pTKq8Egyr185McfiMiV8nyeOHmYO3gNexSVF5jz5rY8,4511
+effspm/htminer/src/build_mdd.hpp,sha256=h-Tp4Qeg1drRQkYqJ0cm33XUPT4yV4e-IYdifgPK1jk,1392
+effspm/htminer/src/freq_miner.cpp,sha256=GzjM4V61nxp9Qtlx9mi8qSAfjNuvOXs0PNAkZBw3XYc,10940
+effspm/htminer/src/freq_miner.hpp,sha256=dOR9wXwMBhnK3yHat6r_8WuehcgPTewb_XCUVM-JTNU,825
+effspm/htminer/src/load_inst.cpp,sha256=jJhijLbsC3mGFH6fSBVXo3fkvKbZouL069jlv-dWbrA,11319
+effspm/htminer/src/load_inst.hpp,sha256=mKC4b0Ji6-WDNP82jcvIi6X4PEVgjmyCp5BSj9VngiE,477
+effspm/htminer/src/utility.cpp,sha256=uVvXQqyeVjJXcdLj8wHL1SLZh0fFda1P428_IgAGWrk,2446
+effspm/htminer/src/utility.hpp,sha256=-tNvJdj6Poz0Vd_em0SYllBR32tqMH8Hmy_SakHeUfk,3650
+effspm/largebm/src/build_mdd.cpp,sha256=7rFfsKMsmVPWpeawgAKhIT1g7IFJDAGND8Ru7E4nnFg,2680
+effspm/largebm/src/build_mdd.hpp,sha256=ie7EYt7Cu8-04-f4QRrboVyxjstor1OB3V6eGAtBQiA,891
+effspm/largebm/src/freq_miner.cpp,sha256=A6DcQRHJoJECbQPLeGpXmQhZtMQdZ8fOcvxlmJxJdRQ,11212
+effspm/largebm/src/freq_miner.hpp,sha256=EaU1SL3K4ZB_7CFhCIv8pS5UkefqGWzr9iTjrDd23XY,911
+effspm/largebm/src/load_inst.cpp,sha256=_Ym6viWbn6XyE8Mo1kMWujj7ud40egkw2M_eMY9lViE,7044
+effspm/largebm/src/load_inst.hpp,sha256=ujfHWuK2W2ptQ8Pal2Z9ZEkwfImbSlZCspdHAg0BsJA,1193
+effspm/largebm/src/utility.cpp,sha256=QfgLD5mss5FIWgWwPzIEPNzTIzEnTTYBzkznYrcGz-M,1084
+effspm/largebm/src/utility.hpp,sha256=CZ70tPKMA5qZnqLGTRdgaqfdWzBb1Gfrc7rKniLOHAo,428
+effspm/largehm/src/build_mdd.cpp,sha256=lev0YbLDfOzVAIJai0MOwtPYBVPJV9DGwU-QaLH_qDY,6090
+effspm/largehm/src/build_mdd.hpp,sha256=HnBzd82X4C-DMoPa7A8vP0_9TxX23_RQ_qm8GkJ-h38,2880
+effspm/largehm/src/freq_miner.cpp,sha256=jfPrFjERi8hnEL4f-_4bML_a082JTj_L477m1-R5PY8,16955
+effspm/largehm/src/freq_miner.hpp,sha256=w-IhZj-k_z3__dikNwvNseapZ1fTAXrFgnPv7o3nzG4,2428
+effspm/largehm/src/load_inst.cpp,sha256=rUnQ2vaQ4qIiXOvBPaXbtbU5dA8SoWI14RG_QSxGhig,12218
+effspm/largehm/src/load_inst.hpp,sha256=7pFao_lo0fRvK1Hn_1nDXvmYleirI153992J7uZKNM0,1692
+effspm/largehm/src/utility.cpp,sha256=jmlLXjOSIFl9p5LWNSmFUuTk6kFXei08xh0qHJNVZ9c,997
+effspm/largehm/src/utility.hpp,sha256=F7qvWtZVqzz9VEBvduouG8pvt5ZHreAtGtXkCWgiafY,720
+effspm/largepp/src/freq_miner.cpp,sha256=wep14Yt0ld_Y76LG1fwYw0zvoB3Vd29enx8GwOQBwDA,7432
+effspm/largepp/src/freq_miner.hpp,sha256=achRvRSVUloeeAbRVhPK0M05pnf4DxSdYTBV8YvOz7w,417
+effspm/largepp/src/load_inst.cpp,sha256=-vcPMdwWv9CMuRRwgn8xRGsQdvUakHIQsUPmP0R1sfg,8302
+effspm/largepp/src/load_inst.hpp,sha256=fDvtWFTiHTIpjA-5n62OAbcS3cFP8XQ_rK1TlVhdpgw,941
+effspm/largepp/src/pattern.hpp,sha256=UNaO53pDLnEoN5Vdyka4Dg9dFrt7ANH51oRXgdpiarA,670
+effspm/largepp/src/utility.cpp,sha256=YzdLehjqe2arQCiAdkdLUZODLYooy_gWltJGhBAHtyc,988
+effspm/largepp/src/utility.hpp,sha256=6zYJWHSqUL3deyvvNqfKQxabtLtRS5Kh52No5zZ78VQ,757
+effspm-0.3.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+effspm-0.3.0.dist-info/METADATA,sha256=KLjqK-ecuSmneSbtCdV3hvXCrnxfeObgJlnYDz5IKy0,14464
+effspm-0.3.0.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+effspm-0.3.0.dist-info/top_level.txt,sha256=2O-AuI0nw0pDmJMo2jzM1wvV2rj48AmkjskkAnsuuQk,7
+effspm-0.3.0.dist-info/RECORD,,