├── Codes
    ├── deg.h
    ├── exec.sh
    ├── semaphore.h
    ├── log.h
    ├── comparator.h
    ├── file_reader.h
    ├── README.md
    ├── SuperpolyBGL.cpp
    ├── thread_pool.h
    ├── flag.h
    ├── deg.cpp
    ├── listsOfPolynomials.h
    └── BooleanPolynomial.h
├── KreyviumSuperpoly
    ├── 896_I1.txt
    ├── 897_I2.txt
    ├── 898_I3.txt
    └── 899_I3.txt
└── README.md


/Codes/deg.h:
--------------------------------------------------------------------------------
 1 | #ifndef __DEG_H__
 2 | #define __DEG_H__
 3 | #include<vector>
 4 | #include<bitset>
 5 | using namespace std;
 6 | 
 7 | int computeDegree( const bitset<128> & cube, const int rounds, const bitset<544> & intervector  );
 8 | 
 9 | #endif
10 | 
11 | 


--------------------------------------------------------------------------------
/Codes/exec.sh:
--------------------------------------------------------------------------------
 1 | export GLIBC_TUNABLES=glibc.malloc.arena_max=8
 2 | rm nohup.out
 3 | rm STATE/*
 4 | rm TERM/*
 5 | rm LOG/*
 6 | g++  SuperpolyBGL.cpp deg.cpp -o mitm -std=c++17 -O2 -lm -lpthread -I/$GUROBI_HOME/include/   -L/$GUROBI_HOME/lib -lgurobi_c++ -lgurobi91 -lm
 7 | 
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/KreyviumSuperpoly/896_I1.txt:
--------------------------------------------------------------------------------
 1 | 1
 2 | s110
 3 | s109
 4 | s102
 5 | s93
 6 | s92
 7 | s83
 8 | s81s82
 9 | s78
10 | s77
11 | s75s76
12 | s73
13 | s70
14 | s57
15 | s56
16 | s55s56
17 | s51
18 | s43
19 | s41
20 | s40
21 | s34
22 | s33
23 | s30
24 | s24
25 | s23
26 | s19
27 | s14
28 | s11
29 | s9
30 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | This is the source code for the paper "Massive Superpoly Recovery with a
2 | Meet-in-the-middle Framework -- Improved Cube Attacks on Trivium and Kreyvium".
3 | 
4 | The file "Codes" contains the source code.
5 | The file "KreyviumSuperpoly" contains the superpolies of Kreyvium. 
6 | 
7 | For example, the file "896_I1" is the 896-round superpoly of the cube indices $I_1$; each line in this file is a monomial (e.g., "s0s1" is the monomial $k[0]k[1]$)
8 | 


--------------------------------------------------------------------------------
/KreyviumSuperpoly/897_I2.txt:
--------------------------------------------------------------------------------
 1 | 1
 2 | s126
 3 | s125
 4 | s123
 5 | s115
 6 | s114
 7 | s113
 8 | s113s114
 9 | s108
10 | s101
11 | s100
12 | s99
13 | s99s100
14 | s98s124
15 | s98s99
16 | s97
17 | s97s98
18 | s92
19 | s88
20 | s86s98
21 | s84s85s98
22 | s80
23 | s74
24 | s72
25 | s71
26 | s68
27 | s67
28 | s66
29 | s66s67
30 | s65
31 | s65s98
32 | s64
33 | s63s64
34 | s62
35 | s59s98
36 | s58
37 | s56
38 | s56s57
39 | s55
40 | s55s113
41 | s55s98
42 | s55s56
43 | s54s114
44 | s51
45 | s49s50
46 | s47s48
47 | s43
48 | s42
49 | s41s99
50 | s41s42
51 | s40
52 | s40s100
53 | s40s98
54 | s40s41
55 | s39s124
56 | s39s99
57 | s39s97
58 | s39s86
59 | s39s84s85
60 | s39s65
61 | s39s59
62 | s39s55
63 | s39s40
64 | s38s98
65 | s38s39
66 | s33
67 | s31
68 | s29
69 | s29s99
70 | s29s86
71 | s29s84s85
72 | s29s59
73 | s29s40
74 | s24
75 | s22
76 | s21
77 | s16
78 | s15
79 | s13
80 | s12
81 | s7
82 | s5s6
83 | s3
84 | 


--------------------------------------------------------------------------------
/Codes/semaphore.h:
--------------------------------------------------------------------------------
 1 | // Copyright (c) 2020 Robert Vaser
 2 | 
 3 | #ifndef THREAD_POOL_SEMAPHORE_HPP_
 4 | #define THREAD_POOL_SEMAPHORE_HPP_
 5 | 
 6 | #include <condition_variable>  // NOLINT
 7 | #include <cstdint>
 8 | #include <memory>
 9 | #include <mutex>  // NOLINT
10 | 
11 | namespace thread_pool {
12 | 
13 | class Semaphore {
14 |  public:
15 |   explicit Semaphore(std::uint32_t count)
16 |       : count_(count) {}
17 | 
18 |   Semaphore(const Semaphore&) = delete;
19 |   Semaphore& operator=(const Semaphore&) = delete;
20 | 
21 |   Semaphore(Semaphore&&) = delete;
22 |   Semaphore& operator=(Semaphore&&) = delete;
23 | 
24 |   ~Semaphore() = default;
25 | 
26 |   void Wait() {
27 |     std::unique_lock<std::mutex> lock(mutex_);
28 |     condition_.wait(lock, [&] () { return count_; });
29 |     --count_;
30 |   }
31 | 
32 |   void Signal() {
33 |     std::unique_lock<std::mutex> lock(mutex_);
34 |     ++count_;
35 |     condition_.notify_one();
36 |   }
37 | 
38 |  private:
39 |   std::uint32_t count_;
40 |   std::mutex mutex_;
41 |   std::condition_variable condition_;
42 | };
43 | 
44 | }  // namespace thread_pool
45 | 
46 | #endif  // THREAD_POOL_SEMAPHORE_HPP_
47 | 


--------------------------------------------------------------------------------
/KreyviumSuperpoly/898_I3.txt:
--------------------------------------------------------------------------------
  1 | 1
  2 | s114
  3 | s113s114
  4 | s112
  5 | s111
  6 | s111s112
  7 | s107
  8 | s105
  9 | s104
 10 | s103
 11 | s102
 12 | s101
 13 | s99
 14 | s95
 15 | s91
 16 | s89s91
 17 | s88
 18 | s87
 19 | s86
 20 | s85
 21 | s84
 22 | s83s84
 23 | s82
 24 | s82s83
 25 | s81
 26 | s80s81
 27 | s77s78
 28 | s76s77
 29 | s75
 30 | s73
 31 | s73s74
 32 | s72
 33 | s71
 34 | s70s100
 35 | s69s100
 36 | s68
 37 | s67s97
 38 | s67s71
 39 | s67s68
 40 | s66s67
 41 | s65
 42 | s65s66s97
 43 | s65s66s71
 44 | s63
 45 | s63s64
 46 | s62
 47 | s61s62
 48 | s60s61
 49 | s58
 50 | s57
 51 | s56
 52 | s56s86
 53 | s56s84s85
 54 | s56s59
 55 | s55
 56 | s55s113
 57 | s54s114
 58 | s54s55s86
 59 | s54s55s84s85
 60 | s54s55s59
 61 | s53
 62 | s53s111
 63 | s53s54
 64 | s52s112
 65 | s52s53
 66 | s51
 67 | s45
 68 | s44
 69 | s43
 70 | s41s70
 71 | s41s69
 72 | s40
 73 | s40s97
 74 | s40s71
 75 | s39s40
 76 | s38s67
 77 | s38s65s66
 78 | s38s40
 79 | s36
 80 | s34
 81 | s32
 82 | s32s89
 83 | s30s91
 84 | s30s32
 85 | s29s86
 86 | s29s84s85
 87 | s29s59
 88 | s27
 89 | s26
 90 | s22s89
 91 | s22s30
 92 | s20
 93 | s19
 94 | s13
 95 | s12s67
 96 | s12s65s66
 97 | s12s40
 98 | s11s100
 99 | s11s41
100 | s10s100
101 | s10s41
102 | s9
103 | 


--------------------------------------------------------------------------------
/Codes/log.h:
--------------------------------------------------------------------------------
 1 | #ifndef __LOG_H__
 2 | #define __LOG_H__
 3 | #include<chrono>
 4 | #include<iostream>
 5 | #include<fstream>
 6 | #include<string>
 7 | #include<malloc.h>
 8 | 
 9 | using namespace std;
10 | 
11 | typedef bool TIMETYPE;
12 | 
13 | const int DATEFLAG = false;
14 | const int TIMEFLAG = true;
15 | 
16 | inline string getCurrentSystemTime(TIMETYPE type)
17 | {
18 |     auto tt = chrono::system_clock::to_time_t(std::chrono::system_clock::now());
19 |     struct tm* ptm = localtime(&tt);
20 |     char date[60] = { 0 };
21 |     if ( type == DATEFLAG )
22 |         sprintf( date, "%d-%02d-%02d", (int)ptm->tm_year + 1900, (int)ptm->tm_mon + 1, (int)ptm->tm_mday );
23 |     else 
24 |         sprintf( date, "%02d:%02d:%02d", (int) ptm->tm_hour, (int)ptm->tm_min, (int)ptm -> tm_sec);
25 | 
26 |     return string(date);
27 | }
28 | 
29 | inline void logger( string logMsg )
30 | {
31 |     string filePath = "LOG/log_" + getCurrentSystemTime( DATEFLAG ) + ".log"; 
32 |     string now = getCurrentSystemTime(TIMEFLAG);
33 |     ofstream os ( filePath.c_str(), ios_base::out | ios_base::app ); 
34 |     os << now << "\t" << logMsg << "\n";
35 |     os.close();
36 | }
37 | 
38 | 
39 | 
40 | #ifndef _WIN32
41 | #include<unistd.h>
42 | inline void showProcessMemUsage()
43 | {
44 |     double virMem = 0;
45 |     double resMem = 0;
46 | 
47 |     fstream fs;
48 |     fs.open("/proc/self/stat", ios_base::in);
49 | 
50 |     int dataCnt = 0;
51 |     string dataStr;
52 |     unsigned long virMemB, resMemP;
53 |     while (fs >> dataStr)
54 |     {
55 |         dataCnt++;
56 |         if (dataCnt == 22)
57 |             break;
58 |     }
59 |     fs >> virMemB >> resMemP;
60 | 
61 |     fs.close();
62 | 
63 |     long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;
64 |     virMem = virMemB / 1024.0 / 1024.0 / 1024.0;
65 |     resMem = resMemP * page_size_kb / 1024.0 / 1024.0;
66 | 
67 |     logger("Current virtual memory usage : " + to_string(virMem) + "G.");
68 |     logger("Current resident memory usage : " + to_string(resMem) + "G.");
69 | }
70 | #endif
71 | 
72 | #endif
73 | 


--------------------------------------------------------------------------------
/Codes/comparator.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <iostream>
 3 | #include <bitset>
 4 | #include "boost/dynamic_bitset.hpp"
 5 | 
 6 | using namespace std;
 7 | using namespace boost;
 8 | 
 9 | template<int N>
10 | class bitset_cmp
11 | {
12 | public:
13 |     bool operator()(const bitset<N>& _l, const bitset<N>& _r) const
14 |     {
15 | 
16 |         for (int i = 0; i < N; i++)
17 |             if (_l[i] < _r[i])
18 |                 return true;
19 |             else if (_l[i] > _r[i])
20 |                 return false;
21 | 
22 |         return false;
23 |     }
24 | };
25 | 
26 | class dynamic_bitset_cmp
27 | {
28 | public:
29 |     bool operator() (const dynamic_bitset<>& _l, const dynamic_bitset<>& _r) const
30 |     {
31 |         int _lSize = _l.size();
32 |         int _rSize = _r.size();
33 |         if (_lSize < _rSize)
34 |             return true;
35 |         else if (_lSize > _rSize)
36 |             return false;
37 | 
38 |         int _Size = _lSize;
39 |         for (int i = 0; i < _Size; i++)
40 |             if (_l[i] < _r[i])
41 |                 return true;
42 |             else if (_l[i] > _r[i])
43 |                 return false;
44 | 
45 |         return false;
46 |     }
47 | };
48 | 
49 | template<int N>
50 | bool operator< (const bitset<N>& _l, const bitset<N>& _r) 
51 | {
52 | 
53 |     for (int i = 0; i < N; i++)
54 |         if (_l[i] < _r[i])
55 |             return true;
56 |         else if (_l[i] > _r[i])
57 |             return false;
58 | 
59 |     return false;
60 | }
61 | 
62 | bool operator< (const dynamic_bitset<>& _l, const dynamic_bitset<>& _r) 
63 | {
64 |     int _lSize = _l.size();
65 |     int _rSize = _r.size();
66 |     if (_lSize < _rSize)
67 |         return true;
68 |     else if (_lSize > _rSize)
69 |         return false;
70 | 
71 |     int _Size = _lSize;
72 |     for (int i = 0; i < _Size; i++)
73 |         if (_l[i] < _r[i])
74 |             return true;
75 |         else if (_l[i] > _r[i])
76 |             return false;
77 | 
78 |     return false;
79 | }
80 | 
81 | using node_pair = pair<dynamic_bitset<>, dynamic_bitset<>>;
82 | 
83 | 
84 | inline bool partial_less(const dynamic_bitset<> _l, const dynamic_bitset<>& _r)
85 | {
86 |     return ((_l & _r) == _l);
87 | }
88 | 
89 | 


--------------------------------------------------------------------------------
/Codes/file_reader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #ifndef __FILE_READER_H
 3 | #define __FILE_READER_H
 4 | 
 5 | #include<map>
 6 | #include<vector>
 7 | #include<filesystem>
 8 | #include<string>
 9 | #include"BooleanPolynomial.h"
10 | #include"dynamic_bitset.hpp"
11 | #include"thread_pool.h"
12 | #include"listsOfPolynomials.h"
13 | 
14 | using namespace std;
15 | using namespace thread_pool;
16 | 
17 | const regex sol_filename_regex(R"~((\d+)_(\d+)_\d+.txt)~");
18 | const regex P_filename_regex(R"~((\d+)_(\d+)_P.txt)~");
19 | const regex sol_start_state_regex(R"~(state from:([01]+))~");
20 | const regex sol_end_state_regex(R"~(state to:([01]+))~");
21 | const regex sol_p_regex(R"~(p(\d+)=(\d+)-(\d+)-([a-zA-Z\d\+]+))~");
22 | const regex integer_regex(R"~((\d+))~");
23 | 
24 | void repeat_match(string& instr, vector<vector<string>>& smatches, const regex pattern)
25 | {
26 | 	string& subject = instr;
27 | 	smatch sm;
28 | 	while (regex_search(subject, sm, pattern))
29 | 	{
30 | 		vector<string> ssmatches;
31 | 		for (auto& ssmatch : sm)
32 | 			ssmatches.emplace_back(ssmatch.str());
33 | 		smatches.emplace_back(ssmatches);
34 | 		subject = sm.suffix().str();
35 | 	}
36 | }
37 | 
38 | class FileReader
39 | {
40 | public:
41 | 
42 | 	void getJustCurrentFilePaths(string path, vector<filesystem::path>& files) const
43 | 	{
44 | 		for (const auto& entry : filesystem::directory_iterator(path))
45 | 			files.emplace_back(entry.path());
46 | 	}
47 | 
48 | 	bool read_one_pair(istream& is, node_pair& state_pair, BooleanPolynomial& coef, ListsOfPolynomialsAsFactors & coef_lists) const
49 | 	{
50 | 		string oneline;
51 | 		while (getline(is, oneline))
52 | 		{
53 | 			if (!oneline.empty())
54 | 				break;
55 | 		}
56 | 
57 | 		if (!is)
58 | 			return false;
59 | 
60 | 		state_pair.first = dynamic_bitset<>(oneline);
61 | 		getline(is, oneline);
62 | 		state_pair.second = dynamic_bitset<>(oneline);
63 | 		getline(is, oneline);
64 | 		coef = BooleanPolynomial(state_pair.first.size(), oneline);
65 | 		coef_lists.load(state_pair.first.size(), is);
66 | 
67 | 		return true;
68 | 	}
69 | 
70 | 
71 | 	bool read_lists_once(istream& is, ListsOfPolynomialsAsFactors& coef_lists, int varsNum) const
72 | 	{
73 | 		return coef_lists.load(varsNum, is);
74 | 	}
75 | 
76 | 
77 | 
78 | 
79 | 
80 | 
81 | };
82 | 
83 | #endif


--------------------------------------------------------------------------------
/Codes/README.md:
--------------------------------------------------------------------------------
 1 | # Reference codes for the paper "Massive Superpoly Recovery with a Meet-in-the-middle Framework -- Improved Cube Attacks on Trivium and Kreyvium"
 2 | 
 3 | ## 1. Structure of the codes
 4 | 
 5 | The header file "BooleanPolynomial.h" defines the class for the representation and operations of Boolean polynomials
 6 | 
 7 | The header file "flag.h" defines the class for the representation and operations of flags.
 8 | 
 9 | The header file "listsOfPolynomials" defines the class for computing the contributions of core monomial trails.
10 | 
11 | The header file "cipher.h" defines the update functions for different ciphers and gives the concrete implementation of our CMP-based approach.
12 | 
13 | The header file "framework.h" gives the concrete implementation of the MITM framework. 
14 | 
15 | The cpp file "SuperpolyBGL.cpp" configures parameters for different ciphers and then calls the MITM framework to recover the superpoly.
16 | 
17 | ## 2. Usage of the codes
18 | We give a brief introduction on how to run our code on a linux platform.
19 | 
20 | 1. Install Gurobi (our version is 9.1.2) and configure the required environment variables such as "GUROBI_HOME" and "LD_LIBRARY_PATH".
21 | 
22 | 2. Open the file "SuperpolyBGL.cpp" to set the *cipher_name*, *cube_index* and *rounds*. 
23 | We provides two options for outputting the superpoly via the variable *solver_mode*. 
24 | 
25 |    Setting *solver_mode* to *mode::OUTPUT_EXP* means once the MITM framework finishes, the concrete expression of the superpoly will be output to the folder "TERM" as a file named "superpoly.txt".
26 | 
27 |    Setting *solver_mode* to *mode::OUTPUT_FILE* means the program will save the contribution of each core monomial trail in an unexpanded form to the folder "TERM". This mode can reduce the memory usage during the running of the program. To recover the exact superpoly under this mode, you can set the variable *isAccurate* to *true* in the main function, then after the program teminates there will be a file named "superpoly.txt" in the folder "TERM" that contains the final superpoly; if you set *isAccurate* to *false*, there will also be a file named "superpoly.txt" in the folder "TERM", but this file contains the unexpanded contributions that appears odd-number times.
28 | 
29 |    Regardless of what *solver_mode* is set to, some information about the superpoly (such as the algebraic degree, the number of monomials appearing in the superpoly, etc.) will end up being output in the standard output.
30 | 
31 | 
32 | 3. Create three folders named "STATE", "LOG" and "TERM" and type `sh exec.sh` in the console. This should generate an executable program "mitm". "LOG" contains log files; "STATE" stores the hash table $P$ after each expansion; "TERM" stores the information of the superpoly that has been extracted by the CMP-based approach.
33 | 
34 | 4. Type `./mitm` in the console to start the superpoly recovery. While the program is running, the status of the program will be recorded in the log files.
35 | 
36 | 
37 | Tips: due to the special memory usage structure of the linux system, if you encounter an out of the memory (OOM) problem when running the program, you can adjust the environment variable *GLIBC_TUNABLES=glibc.malloc.arena_max* in the file "exec.sh". The smaller the value of this variable, the lower the memory consumption, but with some loss of speed.
38 | 
39 | ## 3. Dependencies
40 | Note that the header file "dynamic_bitset.hpp" used in the codes is from the C++ Boost Library, which can be downloaded from (https://www.boost.org/).
41 | 


--------------------------------------------------------------------------------
/Codes/SuperpolyBGL.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <iostream>
  3 | #include <bitset>
  4 | #include <vector>
  5 | #include <string>
  6 | #include <map>
  7 | #include <regex>
  8 | #include "gurobi_c++.h"
  9 | #include "log.h"
 10 | #include "BooleanPolynomial.h"
 11 | #include "framework.h"
 12 | #include "flag.h"
 13 | #include "cipher.h"
 14 | 
 15 | 
 16 | 
 17 | using namespace std;
 18 | 
 19 | 
 20 | 
 21 | int main()
 22 | {
 23 | 
 24 | 	
 25 | 
 26 | 	string cipher_name = "trivium";
 27 | 	set<int> cube_index;
 28 | 	int rounds;
 29 | 	int r0, r1;
 30 | 	int first_expand_step;
 31 | 	int N;
 32 | 	int fbound, cbound0, cbound1;
 33 | 	int min_gap;
 34 | 	int single_threads = 2;
 35 | 	cipher* p_target_cipher = NULL;
 36 | 	mode solver_mode = mode::OUTPUT_FILE;
 37 | 	ThreadPool threadpool;
 38 | 
 39 | 	if (cipher_name == "trivium")
 40 | 	{
 41 | 		
 42 | 		cube_index = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 21,
 43 | 24, 26, 28, 30, 32, 34, 36, 39, 41, 43, 45, 47, 49, 51, 
 44 | 54, 56, 58, 60, 62, 64, 66, 69, 71, 73, 75, 77, 79 };
 45 | 	
 46 | 		
 47 | 
 48 | 		rounds = 849;
 49 | 		r0 = 5;
 50 | 		r1 = 20;
 51 | 		first_expand_step = 300;
 52 | 		N = 50000;
 53 | 		fbound = 350;
 54 | 		cbound0 = 0;
 55 | 		cbound1 = 600;
 56 | 		single_threads = 2;
 57 | 		min_gap = 50;
 58 | 		p_target_cipher = new cipher_trivium();
 59 | 	}
 60 | 	else if (cipher_name == "kreyvium")
 61 | 	{
 62 | 		set<int> noncube_index = { 66, 73, 85, 87 };
 63 | 		for (int i = 0; i < 128; i++)
 64 | 			if (noncube_index.find(i) == noncube_index.end())
 65 | 				cube_index.emplace(i);
 66 | 
 67 | 		rounds = 899;
 68 | 		r0 = 5;
 69 | 		r1 = 20;
 70 | 		first_expand_step = 300;
 71 | 		N = 15000;
 72 | 		fbound = 320;
 73 | 		cbound0 = 0;
 74 | 		cbound1 = 420;
 75 | 		min_gap = 100;
 76 | 		p_target_cipher = new cipher_kreyvium();
 77 | 	}
 78 | 	else if (cipher_name == "grain128AEAD")
 79 | 	{
 80 | 		set<int> noncube_index = { 42,43 };
 81 | 		for (int i = 0; i < 96; i++)
 82 | 			if (noncube_index.find(i) == noncube_index.end())
 83 | 				cube_index.emplace(i);
 84 | 
 85 | 		rounds = 192;
 86 | 		r0 = 1;
 87 | 		r1 = 1;
 88 | 		first_expand_step = 60;
 89 | 		N = 15000;
 90 | 		fbound = 90;
 91 | 		cbound0 = 0;
 92 | 		cbound1 = 150;
 93 | 		min_gap = 20;
 94 | 		p_target_cipher = new cipher_grain128AEAD();
 95 | 	}
 96 | 	else if (cipher_name == "acorn")
 97 | 	{
 98 | 		// the first 256 rounds
 99 | 		set<int> noncube_index = { 2, 28 };
100 | 		for(int i = 0; i < 128; i++)
101 | 			if (noncube_index.find(i) == noncube_index.end())
102 | 				cube_index.emplace(i);
103 | 
104 | 		acorn_basic basic_funcs(293 + 256);
105 | 
106 | 		p_target_cipher = new cipher_acorn256(basic_funcs);
107 | 
108 | 		// expand through the first 256 rounds
109 | 		auto initialcube = p_target_cipher->generate_cube(cube_index);
110 | 		auto initialstate = p_target_cipher->set_initial_state(initialcube);
111 | 
112 | 		framework first256_framework(256, 0, 0, 0, 0, 0, 0, 0, single_threads,
113 | 			solver_mode, threadpool, *p_target_cipher, cube_index, 0);
114 | 		map<dynamic_bitset<>, BooleanPolynomial> expand_state_coeff;
115 | 		map<dynamic_bitset<>, ListsOfPolynomialsAsFactors> state_coeff_lists;
116 | 		first256_framework.noncallback_forwardexpand(0, 256, initialstate, expand_state_coeff, state_coeff_lists, 20, 2);
117 | 		if (expand_state_coeff.size() != 1)
118 | 		{
119 | 			cout << "Expanding to round 256 results in more than one monomial." << endl;
120 | 			exit(-1);
121 | 		}
122 | 		auto &state_coef = (*expand_state_coeff.begin());
123 | 
124 | 		// start to recover the superpoly starting from round 256
125 | 		vector<Flag> round256_flag = first256_framework.getFlag(256);
126 | 		vector<BooleanPolynomial> round256_exps = first256_framework.getExps(256);
127 | 		delete p_target_cipher;
128 | 		basic_funcs.reset(293 + 129);
129 | 
130 | 		p_target_cipher = new cipher_acorn(basic_funcs, round256_flag, round256_exps);
131 | 		
132 | 		auto& round256cube = state_coef.first;
133 | 		auto& round256coef = state_coef.second;
134 | 		if (!round256coef.isone())
135 | 		{
136 | 			cout << "Expanding to round 256 results in a non-zero coeffcient." << endl;
137 | 			exit(-1);
138 | 		}
139 | 
140 | 		cube_index.clear();
141 | 		for (int i = 0; i < 293; i++)
142 | 			if (round256cube[i])
143 | 				cube_index.emplace(i);
144 | 
145 | 		
146 | 		rounds = 776-256;
147 | 		r0 = 2;
148 | 		r1 = 5;
149 | 		first_expand_step = 100;
150 | 		N = 15000;
151 | 		fbound = 450-256;
152 | 		cbound0 = 0;
153 | 		cbound1 = 540-256;
154 | 		min_gap = 50;
155 | 
156 | 	}
157 | 	else
158 | 	{
159 | 		cerr << "The cipher is not defined." << endl;
160 | 		exit(-1);
161 | 	}
162 | 
163 | 
164 | 
165 | 	framework MITM_framework(rounds, r0, r1, first_expand_step, N, fbound, cbound0, cbound1, single_threads,
166 | 		solver_mode, threadpool, *p_target_cipher, cube_index, min_gap);
167 | 
168 | 
169 | 
170 | 	// MITM_framework.debug_test();
171 | 
172 | 	// MITM_framework.generateTikzCodes(250, 0, -40);
173 | 
174 | 	MITM_framework.start();
175 | 
176 | 	// MITM_framework.continue_after_failed(15, 305, false);
177 | 
178 | 	MITM_framework.stop();
179 | 
180 | 	
181 | 	
182 | 	if (solver_mode == mode::OUTPUT_FILE)
183 | 	{
184 | 		// if you want the exact superpoly, then set this variable to true; otherwise set it to false. We recommend true for kreyvium, but false for trivium and grain, otherwise you may encounter an out of memory (OOM) issue. 
185 | 		bool isAccurate = true;
186 | 
187 | 		if (isAccurate)
188 | 		{
189 | 			MITM_framework.read_sols_and_output(true);
190 | 		}
191 | 		else
192 | 		{
193 | 			MITM_framework.read_sols_and_output(false);
194 | 			MITM_framework.analyze_superpoly_asLists();
195 | 		}
196 | 	}
197 | 	else if(solver_mode == mode::OUTPUT_EXP)
198 | 	{
199 | 		MITM_framework.analyze_superpoly();
200 | 	}
201 | 
202 | 
203 | 	
204 | 
205 | 	delete p_target_cipher;
206 | 	
207 | }
208 | 
209 | 


--------------------------------------------------------------------------------
/Codes/thread_pool.h:
--------------------------------------------------------------------------------
  1 | // Copyright(c) 2020 Robert Vaser
  2 | // Combination of ThreadPool implementation by progschj and
  3 | //   task stealing by Sean Parent
  4 | 
  5 | #ifndef THREAD_POOL_THREAD_POOL_HPP_
  6 | #define THREAD_POOL_THREAD_POOL_HPP_
  7 | 
  8 | #include <iostream>
  9 | #include <algorithm>
 10 | #include <atomic>
 11 | #include <functional>
 12 | #include <future>  // NOLINT
 13 | #include <memory>
 14 | #include <queue>
 15 | #include <thread>  // NOLINT
 16 | #include <unordered_map>
 17 | #include <utility>
 18 | #include <vector>
 19 | 
 20 | namespace thread_pool {
 21 | 
 22 |     class ThreadPool {
 23 |     public:
 24 |         explicit ThreadPool(
 25 |             std::size_t num_threads = std::thread::hardware_concurrency())
 26 |             : threads_(),
 27 |             thread_map_(),
 28 |             queues_(1UL > num_threads ? 1UL : num_threads),
 29 |             task_id_(0) {
 30 |             for (std::size_t i = 0; i != queues_.size(); ++i) {
 31 |                 threads_.emplace_back([this, i]() -> void { Task(i); });
 32 |                 thread_map_.emplace(threads_.back().get_id(), i);
 33 |             }
 34 |         }
 35 | 
 36 |         ThreadPool(const ThreadPool&) = delete;
 37 |         ThreadPool& operator=(const ThreadPool&) = delete;
 38 | 
 39 |         ThreadPool(ThreadPool&&) = delete;
 40 |         ThreadPool& operator=(ThreadPool&&) = delete;
 41 | 
 42 |         ~ThreadPool() {
 43 |             for (auto& it : queues_) {
 44 |                 it.Done();
 45 |             }
 46 |             for (auto& it : threads_) {
 47 |                 it.join();
 48 |             }
 49 |         }
 50 | 
 51 |         std::size_t num_threads() const {
 52 |             return threads_.size();
 53 |         }
 54 | 
 55 |         const std::unordered_map<std::thread::id, std::size_t>& thread_map() const {
 56 |             return thread_map_;
 57 |         }
 58 | 
 59 |         template<typename T, typename... Ts>
 60 |         auto Submit(T&& routine, Ts&&... params)
 61 |             -> std::future<typename std::result_of<T(Ts...)>::type> {
 62 |             auto task = std::make_shared<std::packaged_task<typename std::result_of<T(Ts...)>::type()>>(  // NOLINT
 63 |                 std::bind(std::forward<T>(routine), std::forward<Ts>(params)...));
 64 |             auto task_result = task->get_future();
 65 |             auto task_wrapper = [task]() {
 66 |                 (*task)();
 67 |             };
 68 | 
 69 |             auto task_id = task_id_++;
 70 |             bool is_submitted = false;
 71 |             for (std::size_t i = 0; i != queues_.size() * 42; ++i) {
 72 |                 if (queues_[(task_id + i) % queues_.size()].TryPush(task_wrapper)) {
 73 |                     is_submitted = true;
 74 |                     break;
 75 |                 }
 76 |             }
 77 |             if (!is_submitted) {
 78 |                 queues_[task_id % queues_.size()].Push(task_wrapper);
 79 |             }
 80 | 
 81 |             return task_result;
 82 |         }
 83 | 
 84 |     private:
 85 |         void Task(std::size_t thread_id) {
 86 |             while (true) {
 87 |                 std::function<void()> task;
 88 | 
 89 |                 for (std::size_t i = 0; i != queues_.size(); ++i) {
 90 |                     if (queues_[(thread_id + i) % queues_.size()].TryPop(&task)) {
 91 |                         break;
 92 |                     }
 93 |                 }
 94 |                 if (!task && !queues_[thread_id].Pop(&task)) {
 95 |                     break;
 96 |                 }
 97 | 
 98 |                 task();
 99 |             }
100 |         }
101 | 
102 |         struct TaskQueue {
103 |         public:
104 |             template<typename F>
105 |             void Push(F&& f) {
106 |                 {
107 |                     std::unique_lock<std::mutex> lock(mutex);
108 |                     queue.emplace(std::forward<F>(f));
109 |                 }
110 |                 is_ready.notify_one();
111 |             }
112 | 
113 |             bool Pop(std::function<void()>* f) {
114 |                 std::unique_lock<std::mutex> lock(mutex);
115 |                 while (queue.empty() && !is_done) {
116 |                     is_ready.wait(lock);
117 |                 }
118 |                 if (queue.empty()) {
119 |                     return false;
120 |                 }
121 |                 *f = std::move(queue.front());
122 |                 queue.pop();
123 |                 return true;
124 |             }
125 | 
126 |             template<typename F>
127 |             bool TryPush(F&& f) {
128 |                 {
129 |                     std::unique_lock<std::mutex> lock(mutex, std::try_to_lock);
130 |                     if (!lock) {
131 |                         return false;
132 |                     }
133 |                     queue.emplace(std::forward<F>(f));
134 |                 }
135 |                 is_ready.notify_one();
136 |                 return true;
137 |             }
138 | 
139 |             bool TryPop(std::function<void()>* f) {
140 |                 std::unique_lock<std::mutex> lock(mutex, std::try_to_lock);
141 |                 if (!lock || queue.empty()) {
142 |                     return false;
143 |                 }
144 |                 *f = std::move(queue.front());
145 |                 queue.pop();
146 |                 return true;
147 |             }
148 | 
149 |             void Done() {
150 |                 {
151 |                     std::unique_lock<std::mutex> lock(mutex);
152 |                     is_done = true;
153 |                 }
154 |                 is_ready.notify_all();
155 |             }
156 | 
157 |             std::queue<std::function<void()>> queue;
158 |             std::mutex mutex;
159 |             std::condition_variable is_ready;
160 |             bool is_done = false;
161 |         };
162 | 
163 |         std::vector<std::thread> threads_;
164 |         std::unordered_map<std::thread::id, std::size_t> thread_map_;
165 |         std::vector<TaskQueue> queues_;
166 |         std::atomic<std::size_t> task_id_;
167 |     };
168 | 
169 | }  // namespace thread_pool
170 | 
171 | #endif  // THREAD_POOL_THREAD_POOL_HPP_
172 | 


--------------------------------------------------------------------------------
/Codes/flag.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #ifndef __FLAG_H_
  3 | #define __FLAG_H_
  4 | 
  5 | #include <iostream>
  6 | #include <string>
  7 | #include <map>
  8 | 
  9 | 
 10 | 
 11 | using namespace std;
 12 | 
 13 | 
 14 | enum class FLAG { ZERO_C, ONE_C_1, ONE_C_K, DELTA, UNDEFINED };
 15 | map<string, FLAG> str_FLAG_map = {
 16 | 	{"zero_c" , FLAG::ZERO_C},
 17 | 	{"one_c_k", FLAG::ONE_C_K},
 18 | 	{"one_c_1", FLAG::ONE_C_1},
 19 | 	{"delta", FLAG::DELTA}
 20 | };
 21 | 
 22 | map<FLAG, int> add_priority = {
 23 | 	{FLAG::ZERO_C, 0},
 24 | 	{FLAG::ONE_C_1, 1},
 25 | 	{FLAG::ONE_C_K, 2},
 26 | 	{FLAG::DELTA, 3},
 27 | 	{FLAG::UNDEFINED, 4}
 28 | };
 29 | 
 30 | map<FLAG, int> mul_priority = {
 31 | 	{FLAG::ONE_C_1, 0},
 32 | 	{FLAG::ONE_C_K, 1},
 33 | 	{FLAG::DELTA, 2},
 34 | 	{FLAG::ZERO_C, 3},
 35 | 	{FLAG::UNDEFINED, 4}
 36 | };
 37 | 
 38 | map<FLAG, string> FLAG_str_map = {
 39 | 	{FLAG::ZERO_C, "zero_c"},
 40 | 	{FLAG::ONE_C_K, "one_c_k"},
 41 | 	{FLAG::ONE_C_1, "one_c_1"},
 42 | 	{FLAG::DELTA, "delta"},
 43 | 	{FLAG::UNDEFINED, "undefined"}
 44 | };
 45 | 
 46 | 
 47 | 
 48 | class Flag
 49 | {
 50 | private:
 51 | 	FLAG flag;
 52 | public:
 53 | 	Flag() : flag(FLAG::UNDEFINED) {};
 54 | 	Flag(const string s)
 55 | 	{
 56 | 		if (str_FLAG_map.find(s) != str_FLAG_map.end())
 57 | 			flag = str_FLAG_map[s];
 58 | 		else
 59 | 			flag = FLAG::UNDEFINED;
 60 | 	}
 61 | 
 62 | 	void operator= (const string s)
 63 | 	{
 64 | 		if (str_FLAG_map.find(s) != str_FLAG_map.end())
 65 | 			flag = str_FLAG_map[s];
 66 | 		else
 67 | 			flag = FLAG::UNDEFINED;
 68 | 	}
 69 | 
 70 | 	void operator *= (const Flag& rhs)
 71 | 	{
 72 | 		auto lp = mul_priority[flag];
 73 | 		auto rp = mul_priority[rhs.flag];
 74 | 		if (rp > lp)
 75 | 			flag = rhs.flag;
 76 | 	}
 77 | 
 78 | 	void operator += (const Flag& rhs)
 79 | 	{
 80 | 		
 81 | 		if (flag == FLAG::ONE_C_1 &&
 82 | 			rhs.flag == FLAG::ONE_C_1)
 83 | 		{
 84 | 			flag = FLAG::ZERO_C;
 85 | 			return;
 86 | 		}
 87 | 		
 88 | 		
 89 | 
 90 | 
 91 | 		auto lp = add_priority[flag];
 92 | 		auto rp = add_priority[rhs.flag];
 93 | 
 94 | 		if (rp > lp)
 95 | 			flag = rhs.flag;
 96 | 	}
 97 | 
 98 | 	void setflag(const string s)
 99 | 	{
100 | 		if (str_FLAG_map.find(s) != str_FLAG_map.end())
101 | 			flag = str_FLAG_map[s];
102 | 		else
103 | 			flag = FLAG::UNDEFINED;
104 | 	}
105 | 
106 | 	string str() const
107 | 	{
108 | 		return FLAG_str_map[flag];
109 | 	}
110 | 
111 | 	friend ostream& operator << (ostream& os, const Flag& flag)
112 | 	{
113 | 		os << flag.str();
114 | 		return os;
115 | 	}
116 | 
117 | 	friend bool operator == (const Flag & lhs, const Flag & rhs) 
118 | 	{
119 | 		return lhs.flag == rhs.flag;
120 | 	}
121 | 
122 | 	friend bool operator != (const Flag& lhs, const Flag& rhs)
123 | 	{
124 | 		return lhs.flag != rhs.flag;
125 | 	}
126 | 
127 | 	friend bool operator < (const Flag& lhs, const Flag& rhs)
128 | 	{
129 | 		return lhs.flag < rhs.flag;
130 | 	}
131 | 
132 | 	friend bool operator > (const Flag& lhs, const Flag& rhs)
133 | 	{
134 | 		return lhs.flag > rhs.flag;
135 | 	}
136 | 
137 | 	friend Flag operator + (const Flag & lhs, const Flag & rhs) 
138 | 	{
139 | 		
140 | 		if (lhs.flag == FLAG::ONE_C_1 &&
141 | 			rhs.flag == FLAG::ONE_C_1)
142 | 			return Flag("zero_c");
143 | 		
144 | 		
145 | 
146 | 		auto lp = add_priority[lhs.flag];
147 | 		auto rp = add_priority[rhs.flag];
148 | 
149 | 		return (lp < rp) ? rhs : lhs;
150 | 	}
151 | 
152 | 	friend Flag operator * (const Flag& lhs, const Flag& rhs)
153 | 	{
154 | 
155 | 		auto lp = mul_priority[lhs.flag];
156 | 		auto rp = mul_priority[rhs.flag];
157 | 
158 | 		return (lp < rp) ? rhs : lhs;
159 | 	}
160 | 
161 | 	friend bool operator ==(const Flag& lhs, const string rhs)
162 | 	{
163 | 		return (FLAG_str_map[lhs.flag]) == rhs;
164 | 	}
165 | 
166 | 	friend bool operator !=(const Flag& lhs, const string rhs)
167 | 	{
168 | 		return (FLAG_str_map[lhs.flag]) != rhs;
169 | 	}
170 | };
171 | 
172 | /**
173 |  * @brief This class is used to generate the basic tikz code for identifying the delta, 1_c and 0_c bits
174 | */
175 | class FlagDisplay
176 | {
177 | private:
178 | 	vector<Flag> stateFlags;
179 | 	int heightUnit;
180 | 	int widthUnit;
181 | 	int heightBasis;
182 | 	int widthBasis;
183 | 
184 | public:
185 | 
186 | 	FlagDisplay(const vector<Flag>& aStateFlags, int aHeightUnit, int aWidthUnit, int aHeightBasis, int aWidhtBasis) :
187 | 		stateFlags(aStateFlags), heightUnit(aHeightUnit), widthUnit(aWidthUnit),
188 | 		heightBasis(aHeightBasis), widthBasis(aWidhtBasis)
189 | 	{}
190 | 
191 | 	string coordinate(double x, double y)
192 | 	{
193 | 		return "(" + to_string(x) + "," + to_string(y) + ")";
194 | 	}
195 | 
196 | 	string getColor(const Flag& flag)
197 | 	{
198 | 		if (flag == "zero_c")
199 | 			return "gray";
200 | 		else if (flag == "delta")
201 | 			return "green!40";
202 | 		else if (flag == "one_c_1" || flag == "one_c_k")
203 | 			return "red!40";
204 | 		else
205 | 			return "black!40";
206 | 	}
207 | 
208 | 	void generateTikzCodes(ostream & os, int rounds)
209 | 	{
210 | 		// first draw the rectangle as the state
211 | 		int stateSize = stateFlags.size();
212 | 
213 | 		int curX = widthBasis;
214 | 		int curFlagIndex = 0;
215 | 		string curColor = getColor(stateFlags[curFlagIndex]);
216 | 		
217 | 		while (curFlagIndex < stateSize)
218 | 		{
219 | 			int nextFlagIndex = curFlagIndex + 1;
220 | 			while (nextFlagIndex < stateSize && stateFlags[nextFlagIndex] == stateFlags[curFlagIndex])
221 | 				nextFlagIndex++;
222 | 			int nextX = nextFlagIndex * widthUnit + widthBasis;
223 | 
224 | 			os << R"(\draw [dashed, fill=)" << curColor << "] " << coordinate(curX, heightBasis) << " rectangle " << coordinate(nextX, heightBasis + heightUnit)
225 | 				<< ";" << endl;
226 | 
227 | 			if (nextFlagIndex >= stateSize)
228 | 				break;
229 | 
230 | 			curX = nextX;
231 | 			curFlagIndex = nextFlagIndex;
232 | 			curColor = getColor(stateFlags[curFlagIndex]);
233 | 		}
234 | 
235 | 		os << R"(\draw )" + coordinate(widthBasis, heightBasis) + " rectangle " + coordinate(widthUnit * stateSize + widthBasis, heightBasis + heightUnit) + ";" << endl;
236 | 
237 | 		os << R"(\node[scale=15] at )" << coordinate(-15, heightBasis + double(heightUnit) / 2) << R"({Round $)" << rounds << R"($};)" << endl;
238 | 
239 | 	}
240 | };
241 | #endif


--------------------------------------------------------------------------------
/Codes/deg.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<vector>
  3 | #include<algorithm>
  4 | #include<bitset>
  5 | 
  6 | using namespace std;
  7 | 
  8 | #define A 0
  9 | #define B 93
 10 | #define C 177
 11 | 
 12 | #define RA 92
 13 | #define RB 83
 14 | #define RC 110
 15 | 
 16 | /*
 17 |  * la = S242 + S287 + S68
 18 |  * lb = S65 + S92 + S170
 19 |  * lc = S161 + S176 + S263
 20 | */
 21 | 
 22 | vector<int> K(128);
 23 | vector<int> V(128);
 24 | vector<int *> D;
 25 | 
 26 | const int inf = -100000;
 27 | 
 28 | int max( int d1, int d2, int d3 )
 29 | {
 30 |     int m = -10000000;
 31 |     if ( m < d1 ) m = d1;
 32 |     if ( m < d2 ) m = d2;
 33 |     if ( m < d3 ) m = d3;
 34 |     return m;
 35 | }
 36 | 
 37 | int maxx( int d1, int d2, int d3, int d4 )
 38 | {
 39 |     int m = -10000000;
 40 |     if ( m < d1 ) m = d1;
 41 |     if ( m < d2 ) m = d2;
 42 |     if ( m < d3 ) m = d3;
 43 |     if ( m < d4 ) m = d4;
 44 |     return m;
 45 | }
 46 | 
 47 | int max2( int d1, int d2 )
 48 | {
 49 |     if ( d1 > d2 ) return d1;
 50 |     else return d2;
 51 | }
 52 | 
 53 | 
 54 | int min( int d1, int d2, int d3 )
 55 | {
 56 |     int m = 10000000;
 57 |     if ( m > d1 ) m = d1;
 58 |     if ( m > d2 ) m = d2;
 59 |     if ( m > d3 ) m = d3;
 60 |     return m;
 61 | }
 62 | 
 63 | int max7( int d1, int d2, int d3, int d4, int d5, int d6, int d7 )
 64 | {
 65 |     int m = -10000000;
 66 |     if ( m < d1 ) m = d1;
 67 |     if ( m < d2 ) m = d2;
 68 |     if ( m < d3 ) m = d3;
 69 |     if ( m < d4 ) m = d4;
 70 |     if ( m < d5 ) m = d5;
 71 |     if ( m < d6 ) m = d6;
 72 |     if ( m < d7 ) m = d7;
 73 |     return m;
 74 | }
 75 | 
 76 | int At( int t1 )
 77 | {
 78 |     if ( t1 < 0 )
 79 |         return D[0][A - t1];
 80 |     else
 81 |         return D[t1][A];
 82 | }
 83 | 
 84 | int Bt( int t1 )
 85 | {
 86 |     if ( t1 < 0 )
 87 |         return D[0][B - t1];
 88 |     else
 89 |         return D[t1][B];
 90 | }
 91 | 
 92 | int Ct( int t1 )
 93 | {
 94 |     if ( t1 < 0 )
 95 |         return D[0][C - t1];
 96 |     else
 97 |         return D[t1][C];
 98 | }
 99 | 
100 | 
101 | int * update( int t )
102 | {
103 |     int ga, gb, gc;
104 |     int t1, t2;
105 |     int d1, d2, d3;
106 | 
107 |     // ga
108 |     t1 = t - RC;
109 | 
110 |     if ( t1 <= 0 )
111 |         ga = Ct(t1) + Ct(t1+ 1);
112 |     else
113 |     {
114 |         t2 = t1 - RB; 
115 |         //d1 = min( D[t2][B] + D[t1+1][C], D[t2 + 2][B] + D[t2][C], D[t2][B] + D[t2+1][B] + D[t2+2][B] );
116 |         d1 = min( Bt(t2) + Ct(t1+1), Bt(t2+2 ) + Ct(t1), Bt( t2 ) + Bt( t2+1 ) + Bt( t2+2 ) );
117 | 
118 |         d2 = max( D[t1][161], D[t1][176], D[t1][263] ) + Ct(t1);
119 |             
120 |         d3 = max( D[t1 - 1][161], D[t1 - 1][176], D[t1 - 1][263] ) + Ct(t1+1);
121 | 
122 |         ga = max( d1, d2, d3 );
123 |     }
124 | 
125 |     int la = maxx( D[t - 1][242], D[t - 1][287], D[t - 1][68], K[0] );
126 | 	// K circle
127 | 	int tmppp = K[0];
128 | 	for ( int i = 0; i< 127; i++ )
129 | 		K[i] = K[i + 1];
130 | 	K[127] = tmppp;
131 | 
132 |     // gb
133 |     t1 = t - RA;
134 |     if ( t1 <= 0 )
135 |         gb = At(t1) + At(t1+ 1);
136 |     else
137 |     {
138 | /*
139 |  * la = S242 + S287 + S68
140 |  * lb = S65 + S92 + S170
141 |  * lc = S161 + S176 + S263
142 | */
143 |         t2 = t1 - RC; 
144 |         //d1 = min( D[t2][C] + D[t1+1][A], D[t2 + 2][C] + D[t2][A], D[t2][C] + D[t2+1][C] + D[t2+2][C] );
145 |         d1 = min( Ct(t2) + At(t1+1), Ct(t2 + 2) + At(t1), Ct(t2) + Ct(t2+1) + Ct(t2+2) );
146 |         d2 = max( D[t1][242], D[t1][287], D[t1][68] ) + At(t1);
147 |         d3 = max( D[t1 - 1][242], D[t1 - 1][287], D[t1 - 1][68] ) + At(t1+1);
148 |         gb = max( d1, d2, d3 );
149 |     }
150 | 
151 |     int lb = maxx( D[t - 1][65], D[t - 1][92], D[t - 1][170], V[0] );
152 | 	// V circle
153 | 	int tmpp = V[0];
154 | 	for ( int i = 0; i< 127; i++ )
155 | 		V[i] = V[i + 1];
156 | 	V[127] = tmpp;
157 |         
158 |     //gc
159 |     t1 = t - RB;
160 |     if ( t1 <= 0 )
161 |         gc = Bt(t1) + Bt(t1+ 1);
162 |     else
163 |     {
164 |         t2 = t1 - RA; 
165 |         //d1 = min( D[t2][A] + D[t1+1][B], D[t2 + 2][A] + D[t2][B], D[t2][A] + D[t2+1][A] + D[t2+2][A] );
166 |         d1 = min( At(t2) + Bt(t1+1), At(t2 + 2) + Bt(t1), At(t2) + At(t2+1) + At(t2+2) );
167 |         d2 = max( D[t1][65], D[t1][92], D[t1][170] ) + Bt(t1);
168 |         d3 = max( D[t1 - 1][65], D[t1 - 1][92], D[t1 - 1][170] ) + Bt(t1+1);
169 |         gc = max( d1, d2, d3 );
170 |     }
171 | 
172 |     int lc = max( D[t - 1][161], D[t - 1][176], D[t - 1][263] );
173 | /*
174 |  * la = S242 + S287 + S68
175 |  * lb = S65 + S92 + S170
176 |  * lc = S161 + S176 + S263
177 | */
178 |     int * p = new int[288];
179 | 
180 |     for ( int i = 0; i < 288; i++ ) 
181 |         if ( ( i != A ) && ( i != B ) && ( i != C ) ) 
182 |             p[i] = D[t-1][ (i + 287) % 288];
183 |     
184 |     p[A] = max2( ga, la );
185 |     p[B] = max2( gb, lb );
186 |     p[C] = max2( gc, lc );
187 | 
188 |     //for ( int i = 0; i < 288; i++ )
189 |     //  cout << p[i] << '\t';
190 |     //cout << endl;
191 |     return p;
192 | }
193 | 
194 | int computeDegree( const bitset<128>& cube, const int rounds, const bitset<544> & intervector  )
195 | //int computeDegree( const bitset<128>& cube, const int rounds )
196 | {
197 |     D.clear();
198 |     int * p = new int[288];
199 | 
200 | 	// key
201 |     for ( int i = 0; i < 93; i++ )
202 | 		p[i] = 0;
203 | 
204 | 	for ( int i = 93; i < 93 + 128; i++ )
205 | 		if ( cube[i - 93] == 1 )
206 | 			p[i] = 1;
207 | 		else
208 | 			p[i] = inf;
209 | 
210 | 	for ( int i = 93 + 128; i < 287; i++ )
211 | 		p[i] = 0;
212 | 
213 | 	p[287] = inf;
214 | 
215 |     D.push_back( p );
216 | 
217 | 	// initialize K and V
218 | 	for ( int i = 0; i < 128; i++ )
219 | 		K[i] = 0;
220 | 
221 | 	for ( int i = 0; i < 128; i++ )
222 | 		if ( cube[i] == 1 )
223 | 			V[i] = 1;
224 | 		else
225 | 			V[i] = inf;
226 | 
227 |     int degree = 0;
228 |     for ( int i = 1; i < rounds + 1; i++ )
229 |     {
230 |         D.push_back ( update( i ) );
231 |     }
232 | 
233 |     for ( int j = 0; j < 128; j++ )
234 |         if ( intervector[j + 288 + 128] == 1 )
235 |             degree += K[j];
236 |     for ( int j = 0; j < 128; j++ )
237 |         if ( intervector[j + 288] == 1 )
238 |             degree += V[j];
239 |     for ( int j = 0; j < 288; j++ )
240 |         if ( intervector[j] == 1 )
241 |             degree += D[rounds][j];
242 | 
243 |     //auto degree = max7 ( D[rounds][65], D[rounds][92], D[rounds][161],
244 |     //			D[rounds][176], D[rounds][242], D[rounds][287], K[0] ) ; 
245 |     //cout << "ROUND: [" << i << "] " << "DEGREE: [" << deg << "]" << endl;
246 | 
247 | 	for ( auto & it : D )
248 | 		delete [] it;
249 | 
250 |     return degree;
251 | }
252 | 
253 | 
254 | /*
255 | int main()
256 | {
257 |     //int I_liu[] = {0, 2, 4, 6, 8, 10, 12, 15, 17, 19, 21, 23, 25, 27, 30, 32, 34, 36, 38, 40, 42, 45, 47, 49, 51, 53, 55, 57, 60, 62, 64, 66, 68, 70, 72, 75, 79};
258 |     vector<int> cube {0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 29, 31,
259 | 		33, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 57, 59, 61, 63, 65, 67, 69,
260 | 		72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104,
261 | 		107, 109, 111, 113, 115, 117, 119, 122, 124, 126 };
262 | 
263 | 	bitset<128> I;
264 | 	for ( int i = 0; i < 128; i++ )
265 | 		I[i] = 1;
266 | 
267 | 	cout << cube.size() << endl;
268 | 	for ( int i = 0; i < 1000; i++ )
269 | 		cout << i << " " << computeDegree( I, i ) << endl;
270 | }
271 | */
272 | 
273 | 


--------------------------------------------------------------------------------
/Codes/listsOfPolynomials.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #ifndef __LISTSOFPOLYNOMIALS_H_
  3 | #define __LISTSOFPOLYNOMIALS_H_
  4 | #include <iostream>
  5 | #include <vector>
  6 | #include <set>
  7 | #include "BooleanPolynomial.h"
  8 | #include "log.h"
  9 | 
 10 | using namespace std;
 11 | 
 12 | class ListOfPolynomialsAsFactors
 13 | {
 14 | private:
 15 | 	set<BooleanPolynomial> listOfPolynomials;
 16 | 	int varsNum;
 17 | 
 18 | public:
 19 | 	ListOfPolynomialsAsFactors(int aVarsNum = 0) : varsNum(aVarsNum) {};
 20 | 
 21 | 	ListOfPolynomialsAsFactors(const BooleanPolynomial& aPoly)
 22 | 	{
 23 | 		if (aPoly.isnull())
 24 | 		{
 25 | 			logger(__func__ + string(": try to add a null polynomial."));
 26 | 			exit(-1);
 27 | 		}
 28 | 
 29 | 		varsNum = aPoly.size();
 30 | 		if (!aPoly.isone())
 31 | 			listOfPolynomials.emplace(aPoly);
 32 | 	}
 33 | 
 34 | 	void add(const BooleanPolynomial& aPoly)
 35 | 	{
 36 | 		if (aPoly.isnull())
 37 | 		{
 38 | 			logger(__func__ + string(": try to add a null polynomial."));
 39 | 			exit(-1);
 40 | 		}
 41 | 
 42 | 
 43 | 		if (listOfPolynomials.size() == 0 && varsNum == 0)
 44 | 		{
 45 | 			varsNum = aPoly.size();
 46 | 		}
 47 | 		else
 48 | 		{
 49 | 			if (varsNum != aPoly.size())
 50 | 			{
 51 | 				logger(__func__ + string(": mismatch in the number of variables."));
 52 | 				exit(-1);
 53 | 			}
 54 | 		}
 55 | 
 56 | 		if (!aPoly.isone())
 57 | 			listOfPolynomials.emplace(aPoly);
 58 | 
 59 | 	}
 60 | 
 61 | 	BooleanPolynomial getProd() const
 62 | 	{
 63 | 		BooleanPolynomial prod = fastmul(varsNum, listOfPolynomials);
 64 | 		return prod;
 65 | 	}
 66 | 
 67 | 	int eval(const map<int, int>& vals) const
 68 | 	{
 69 | 		int res = 1;
 70 | 		for (auto& poly : listOfPolynomials)
 71 | 		{
 72 | 			res *= poly.eval(vals);
 73 | 			if (res == 0)
 74 | 				return 0;
 75 | 		}
 76 | 
 77 | 		return res;
 78 | 	}
 79 | 
 80 | 
 81 | 	
 82 | 
 83 | 	int maxDeg() const
 84 | 	{
 85 | 		int max_deg = 0;
 86 | 		for (auto& poly : listOfPolynomials)
 87 | 			max_deg += poly.deg();
 88 | 		
 89 | 		return max_deg;
 90 | 	}
 91 | 
 92 | 	int maxNrTerms() const
 93 | 	{
 94 | 		int max_num_terms = 1;
 95 | 		for (auto& poly : listOfPolynomials)
 96 | 			max_num_terms *= poly.moncnt();
 97 | 		return max_num_terms;
 98 | 	}
 99 | 
100 | 	int getVarsNum() const { return varsNum; }
101 | 
102 | 	void merge(ListOfPolynomialsAsFactors& otherList)
103 | 	{
104 | 		if (varsNum != otherList.varsNum)
105 | 		{
106 | 			logger(__func__ + string(": try to add a null polynomial."));
107 | 			exit(-1);
108 | 		}
109 | 
110 | 		listOfPolynomials.merge(otherList.listOfPolynomials);
111 | 	}
112 | 
113 | 	void merge(const ListOfPolynomialsAsFactors& otherList)
114 | 	{
115 | 		if (varsNum != otherList.varsNum)
116 | 		{
117 | 			logger(__func__ + string(": try to add a null polynomial."));
118 | 			exit(-1);
119 | 		}
120 | 
121 | 		listOfPolynomials.insert(otherList.listOfPolynomials.begin(), otherList.listOfPolynomials.end());
122 | 	}
123 | 
124 | 	friend ListOfPolynomialsAsFactors operator * (const ListOfPolynomialsAsFactors& l0, const ListOfPolynomialsAsFactors& l1)
125 | 	{
126 | 		if (l0.varsNum != l1.varsNum)
127 | 		{
128 | 			logger(__func__ + string(": mismatch in the number of variables."));
129 | 			exit(-1);
130 | 		}
131 | 
132 | 		ListOfPolynomialsAsFactors newList(l0.varsNum);
133 | 		set_union(l0.listOfPolynomials.begin(), l0.listOfPolynomials.end(), l1.listOfPolynomials.begin(), l1.listOfPolynomials.end(), insert_iterator(newList.listOfPolynomials, newList.listOfPolynomials.end()));
134 | 
135 | 		return newList;
136 | 	}
137 | 
138 | 	friend bool operator< (const ListOfPolynomialsAsFactors& l0, const ListOfPolynomialsAsFactors& l1)
139 | 	{
140 | 		if (l0.varsNum < l1.varsNum)
141 | 			return true;
142 | 		else if (l0.varsNum > l1.varsNum)
143 | 			return false;
144 | 
145 | 		auto it0 = l0.listOfPolynomials.begin();
146 | 		auto it1 = l1.listOfPolynomials.begin();
147 | 
148 | 		while (it0 != l0.listOfPolynomials.end() && it1 != l1.listOfPolynomials.end())
149 | 		{
150 | 			if (*it0 < *it1)
151 | 				return true;
152 | 			else if (*it0 > * it1)
153 | 				return false;
154 | 
155 | 			it0++;
156 | 			it1++;
157 | 		}
158 | 
159 | 		if (it0 == l0.listOfPolynomials.end() && it1 != l1.listOfPolynomials.end())
160 | 			return true;
161 | 
162 | 		return false;
163 | 	}
164 | 
165 | 	void display(ostream& fout) const
166 | 	{
167 | 		if (listOfPolynomials.size() == 0)
168 | 		{
169 | 			fout << "(1)" << endl;
170 | 			return;
171 | 		}
172 | 
173 | 		for (auto& poly : listOfPolynomials)
174 | 			fout << "(" << poly << ")";
175 | 
176 | 		fout << endl;
177 | 	}
178 | 
179 | 	void load(int aVarsNum, const string& str)
180 | 	{
181 | 		varsNum = aVarsNum;
182 | 		listOfPolynomials.clear();
183 | 
184 | 		if (str == "(1)")
185 | 			listOfPolynomials.clear();
186 | 		else
187 | 		{
188 | 			string polystr;
189 | 			for (int i = 0; i < str.size(); i++)
190 | 			{
191 | 				if (str[i] == '(')
192 | 					polystr = "";
193 | 				else if (str[i] == ')')
194 | 				{
195 | 					BooleanPolynomial poly(aVarsNum, polystr);
196 | 					listOfPolynomials.emplace(poly);
197 | 				}
198 | 				else
199 | 				{
200 | 					polystr += str[i];
201 | 				}
202 | 			}
203 | 		}
204 | 
205 | 	}
206 | 
207 | 
208 | 
209 | 
210 | 	auto begin() const
211 | 	{
212 | 		return listOfPolynomials.begin();
213 | 	}
214 | 
215 | 	auto end() const
216 | 	{
217 | 		return listOfPolynomials.end();
218 | 	}
219 | };
220 | 
221 | class ListsOfPolynomialsAsFactors
222 | {
223 | private:
224 | 	vector<ListOfPolynomialsAsFactors> listsOfPolynomials;
225 | 	int varsNum;
226 | public:
227 | 	ListsOfPolynomialsAsFactors(int aVarsNum = 0) : varsNum(aVarsNum) {};
228 | 
229 | 	ListsOfPolynomialsAsFactors(const ListOfPolynomialsAsFactors& aList)
230 | 	{
231 | 		varsNum = aList.getVarsNum();
232 | 		listsOfPolynomials.emplace_back(aList);
233 | 	}
234 | 
235 | 	void add(const ListOfPolynomialsAsFactors& list)
236 | 	{
237 | 		int listVarsNum = list.getVarsNum();
238 | 
239 | 		if (listsOfPolynomials.size() == 0 && varsNum == 0)
240 | 			varsNum = listVarsNum;
241 | 		else
242 | 		{
243 | 			if (listVarsNum != varsNum)
244 | 			{
245 | 				logger(__func__ + string(": mismatch in the number of variables."));
246 | 				exit(-1);
247 | 			}
248 | 		}
249 | 
250 | 		listsOfPolynomials.emplace_back(list);
251 | 	}
252 | 
253 | 	/**
254 | 	 * @brief This function is used to remove those lists of polynomials that occur an even-number of times
255 | 	*/
256 | 	void filterLists()
257 | 	{
258 | 		map<ListOfPolynomialsAsFactors, int> listCounter;
259 | 		for (auto& list : listsOfPolynomials)
260 | 			listCounter[list]++;
261 | 
262 | 		listsOfPolynomials.clear();
263 | 		for (auto& list_cnt : listCounter)
264 | 			if (list_cnt.second % 2)
265 | 				listsOfPolynomials.emplace_back(list_cnt.first);
266 | 	}
267 | 
268 | 	int eval(const map<int, int>& vals) const
269 | 	{
270 | 		int res = 0;
271 | 		for (auto& list : listsOfPolynomials)
272 | 		{
273 | 			res ^= list.eval(vals);
274 | 		}
275 | 		return res;
276 | 	}
277 | 
278 | 	BooleanPolynomial getSum() const
279 | 	{
280 | 		vector<BooleanPolynomial> prodsOfLists;
281 | 		for (auto& list : listsOfPolynomials)
282 | 			prodsOfLists.emplace_back(list.getProd());
283 | 
284 | 		return fastsum(varsNum, prodsOfLists);
285 | 	}
286 | 
287 | 	int maxDeg() const
288 | 	{
289 | 		int max_deg = 0;
290 | 		for (auto& list : listsOfPolynomials)
291 | 		{
292 | 			int tmp_deg = list.maxDeg();
293 | 			if (tmp_deg > max_deg)
294 | 				max_deg = tmp_deg;
295 | 		}
296 | 
297 | 		return max_deg;
298 | 	}
299 | 
300 | 	int maxNrTerms() const
301 | 	{
302 | 		int max_num_terms = 0;
303 | 		for (auto& list : listsOfPolynomials)
304 | 			max_num_terms += list.maxNrTerms();
305 | 		return max_num_terms;
306 | 	}
307 | 
308 | 	void display(ostream& fout) const
309 | 	{
310 | 		for (auto& list : listsOfPolynomials)
311 | 			list.display(fout);
312 | 
313 | 		fout << endl;
314 | 	}
315 | 
316 | 	bool load(int aVarsNum, istream& is)
317 | 	{
318 | 		varsNum = aVarsNum;
319 | 		listsOfPolynomials.clear();
320 | 
321 | 		string oneline;
322 | 
323 | 		// omit the first empty lines
324 | 		while (getline(is, oneline))
325 | 		{
326 | 			if (!oneline.empty())
327 | 				break;
328 | 		}
329 | 
330 | 		if (!is)
331 | 		{
332 | 			return false;
333 | 		}
334 | 
335 | 		ListOfPolynomialsAsFactors list;
336 | 		list.load(aVarsNum, oneline);
337 | 		listsOfPolynomials.emplace_back(list);
338 | 
339 | 		while (getline(is, oneline))
340 | 		{
341 | 			if (oneline.empty())
342 | 				break;
343 | 
344 | 			list.load(aVarsNum, oneline);
345 | 			listsOfPolynomials.emplace_back(list);
346 | 		}
347 | 
348 | 		return true;
349 | 	}
350 | 
351 | 
352 | 	friend ostream& operator << (ostream& os, const ListsOfPolynomialsAsFactors& ls)
353 | 	{
354 | 		ls.display(os);
355 | 		return os;
356 | 	}
357 | 
358 | 	friend ListsOfPolynomialsAsFactors operator * (const ListsOfPolynomialsAsFactors& ls0, const ListsOfPolynomialsAsFactors& ls1)
359 | 	{
360 | 		if (ls0.varsNum != ls1.varsNum)
361 | 		{
362 | 			logger(__func__ + string(": mismatch in the number of variables."));
363 | 			exit(-1);
364 | 		}
365 | 
366 | 
367 | 		ListsOfPolynomialsAsFactors newLists(ls0.varsNum);
368 | 		for (auto& l0 : ls0.listsOfPolynomials)
369 | 			for (auto& l1 : ls1.listsOfPolynomials)
370 | 			{
371 | 				ListOfPolynomialsAsFactors newList = l0 * l1;
372 | 				newLists.add(newList);
373 | 			}
374 | 
375 | 		return newLists;
376 | 	}
377 | 
378 | 	void operator *=(const ListOfPolynomialsAsFactors& otherList)
379 | 	{
380 | 		if (varsNum != otherList.getVarsNum())
381 | 		{
382 | 			logger(__func__ + string(": mismatch in the number of variables."));
383 | 			exit(-1);
384 | 		}
385 | 
386 | 		for (auto& list : listsOfPolynomials)
387 | 		{
388 | 			list.merge(otherList);
389 | 		}
390 | 	}
391 | 
392 | 	void operator += (const ListsOfPolynomialsAsFactors& otherLists)
393 | 	{
394 | 		if (varsNum != otherLists.varsNum)
395 | 		{
396 | 			logger(__func__ + string(": mismatch in the number of variables."));
397 | 			exit(-1);
398 | 		}
399 | 
400 | 		listsOfPolynomials.insert(listsOfPolynomials.end(), otherLists.listsOfPolynomials.begin(), otherLists.listsOfPolynomials.end());
401 | 	}
402 | 
403 | 	auto begin() const
404 | 	{
405 | 		return listsOfPolynomials.begin();
406 | 	}
407 | 
408 | 	auto end() const
409 | 	{
410 | 		return listsOfPolynomials.end();
411 | 	}
412 | 
413 | 
414 | 
415 | };
416 | #endif


--------------------------------------------------------------------------------
/Codes/BooleanPolynomial.h:
--------------------------------------------------------------------------------
   1 | #pragma once
   2 | #ifndef __BOOLEANPOLYNOMIAL_H_
   3 | #define __BOOLEANPOLYNOMIAL_H_
   4 | #include<iostream>
   5 | #include<map>
   6 | #include<vector>
   7 | #include<set>
   8 | #include<string>
   9 | #include<regex>
  10 | #include<cctype>
  11 | #include "boost/dynamic_bitset.hpp"
  12 | #include "comparator.h"
  13 | 
  14 | using namespace std;
  15 | using namespace boost;
  16 | 
  17 | // A personal implementation of Boolean Monomial and Polynomial
  18 | // Not so professional  : )
  19 | 
  20 | 
  21 | static string remove_blank(const string instr)
  22 | {
  23 |     string subject = instr;
  24 |     subject.erase(remove_if(subject.begin(), subject.end(), ::isspace), subject.end());
  25 |     return subject;
  26 | }
  27 | 
  28 | static bool find_repeat_patterns(string & instr, vector<vector<string>>& smatches, const regex pattern)
  29 | {
  30 |     string & subject = instr;
  31 |     smatch sm;
  32 |     while (regex_search(subject, sm, pattern, regex_constants::match_continuous))
  33 |     {
  34 |         vector<string> ssmatches;
  35 |         for (auto& ssmatch : sm)
  36 |             ssmatches.emplace_back(ssmatch.str());
  37 |         smatches.emplace_back(ssmatches);
  38 |         subject = sm.suffix().str();
  39 |     }
  40 | 
  41 |     if (!subject.empty())
  42 |     {
  43 |         return false;
  44 |     }
  45 |     else
  46 |         return true;
  47 | }
  48 | 
  49 | 
  50 | namespace BooleanResolution
  51 | {
  52 |     enum class SYMBOL_TYPE {ALPHA, ZERO, ONE, UNDEFINED};
  53 |     using SYMBOL_VALUE = char;
  54 | 
  55 |     class symbol
  56 |     {
  57 |     public:
  58 |         SYMBOL_VALUE val;
  59 |         SYMBOL_TYPE type;
  60 | 
  61 |         symbol() : type(SYMBOL_TYPE::UNDEFINED), val('?') {};
  62 |         symbol(const char v)
  63 |         {
  64 |             switch (v)
  65 |             {
  66 |             case '0':
  67 |                 type = SYMBOL_TYPE::ZERO;
  68 |                 val = '0';
  69 |                 break;
  70 |             case '1':
  71 |                 type = SYMBOL_TYPE::ONE;
  72 |                 val = '1';
  73 |                 break;
  74 |             default:
  75 |                 if (isalpha(v))
  76 |                 {
  77 |                     type = SYMBOL_TYPE::ALPHA;
  78 |                     val = v;
  79 |                     break;
  80 |                 }
  81 |                 else
  82 |                 {
  83 |                     type = SYMBOL_TYPE::UNDEFINED;
  84 |                     val = '?';
  85 |                     break;
  86 |                 }
  87 | 
  88 |             }
  89 |         }
  90 |         symbol(const symbol& s) : type(s.type), val(s.val) {};
  91 | 
  92 |         void setval(const char v)
  93 |         {
  94 |             switch (v)
  95 |             {
  96 |             case '0':
  97 |                 type = SYMBOL_TYPE::ZERO;
  98 |                 val = '0';
  99 |                 break;
 100 |             case '1':
 101 |                 type = SYMBOL_TYPE::ONE;
 102 |                 val = '1';
 103 |                 break;
 104 |             default:
 105 |                 if (isalpha(v))
 106 |                 {
 107 |                     type = SYMBOL_TYPE::ALPHA;
 108 |                     val = v;
 109 |                     break;
 110 |                 }
 111 |                 else
 112 |                 {
 113 |                     type = SYMBOL_TYPE::UNDEFINED;
 114 |                     val = '?';
 115 |                     break;
 116 |                 }
 117 | 
 118 |             }
 119 |         }
 120 |     };
 121 | 
 122 |     const regex MonomialRegex(R"~(([a-zA-Z])(\d+))~");
 123 | 
 124 |     using MonomialInf = pair<symbol, set<int>>;
 125 | 
 126 |     MonomialInf resolve_mon_exp(const string monexp)
 127 |     {
 128 |         MonomialInf moninf;
 129 |         string exp = remove_blank(monexp);
 130 | 
 131 |         if (exp == "0")
 132 |         {
 133 |             moninf.first.setval('0');
 134 |             return moninf;
 135 |         }
 136 |         else if (exp == "1")
 137 |         {
 138 |             moninf.first.setval('1');
 139 |             return moninf;
 140 |         }
 141 |         else
 142 |         {
 143 |             vector<vector<string>> smatches;
 144 |             auto isvalid = find_repeat_patterns(exp, smatches, MonomialRegex);
 145 | 
 146 | 
 147 |             symbol s;
 148 |             if (isvalid)
 149 |             {
 150 |                 set<int> vi;
 151 |                 for (auto& sm : smatches)
 152 |                 {
 153 |                     if (s.type == SYMBOL_TYPE::UNDEFINED)
 154 |                     {
 155 |                         vi.emplace(stoi(sm[2]));
 156 |                         s.setval(sm[1][0]);
 157 |                     }
 158 |                     else
 159 |                         if (s.val == sm[1][0])
 160 |                         {
 161 |                             vi.emplace(stoi(sm[2]));
 162 |                             continue;
 163 |                         }
 164 |                         else
 165 |                             return moninf;
 166 |                 }
 167 | 
 168 |                 moninf.first = s;
 169 |                 moninf.second = vi;
 170 |             }
 171 | 
 172 |             return moninf;
 173 |         }
 174 |     }
 175 | 
 176 |     using PolyInf = vector<MonomialInf>;
 177 | 
 178 |     PolyInf resolve_poly_exp(const string polyexp)
 179 |     {
 180 |         string exp = remove_blank(polyexp);
 181 | 
 182 |         regex plus_regex(R"~(\+)~");
 183 |         sregex_token_iterator rend;
 184 | 
 185 |         sregex_token_iterator rbegin(exp.begin(), exp.end(), plus_regex, -1);
 186 | 
 187 |         PolyInf moninfs;
 188 | 
 189 |         for (auto i = rbegin; i != rend; i++)
 190 |         {
 191 |             string monexp = i->str();
 192 | 
 193 | 
 194 |             if (monexp.empty())
 195 |             {
 196 |                 moninfs.clear();
 197 |                 return moninfs;
 198 |             }
 199 | 
 200 |             
 201 |             auto moninf = resolve_mon_exp(monexp);
 202 |             auto& monsymbol = moninf.first;
 203 |             if (monsymbol.type == SYMBOL_TYPE::UNDEFINED)
 204 |             {
 205 |                 moninfs.clear();
 206 |                 return moninfs;
 207 |             }
 208 | 
 209 |             moninfs.emplace_back(moninf);
 210 |         }
 211 | 
 212 |         return moninfs;
 213 | 
 214 |     }
 215 | 
 216 | 
 217 | 
 218 | };
 219 | 
 220 | 
 221 | 
 222 | class BooleanPolynomial;
 223 | 
 224 | class BooleanMonomial
 225 | {
 226 | private:
 227 |     friend class BooleanPolynomial;
 228 |     
 229 |     int coefficient = 1;
 230 | 
 231 |     dynamic_bitset<> monrep;
 232 | 
 233 | 
 234 | 
 235 | public:
 236 |     BooleanMonomial() {};
 237 | 
 238 |     BooleanMonomial(const BooleanMonomial& _mon) : monrep(_mon.monrep), coefficient(_mon.coefficient) {};
 239 | 
 240 |     BooleanMonomial(int ini_size, int c = 1) { monrep.resize(ini_size);  coefficient = c; }
 241 | 
 242 | private:
 243 |     BooleanMonomial(const dynamic_bitset<> rep) : monrep(rep) {}
 244 | 
 245 |     BooleanMonomial(int ini_size, const set<int>& true_index)
 246 |     {
 247 |         monrep.resize(ini_size);
 248 |         for (auto& i : true_index)
 249 |         {
 250 |             if(i < ini_size)
 251 |                 monrep[i] = 1;
 252 |             else
 253 |             {
 254 |                 monrep.resize(0);
 255 |                 break;
 256 |             }
 257 |         }
 258 |     }
 259 | 
 260 | 
 261 | 
 262 |     BooleanMonomial(int ini_size, const string monexp)
 263 |     {
 264 | 
 265 |         
 266 |         string exp = remove_blank(monexp);
 267 |         using BooleanResolution::MonomialInf;
 268 |         using BooleanResolution::resolve_mon_exp;
 269 |         using BooleanResolution::SYMBOL_TYPE;
 270 |         MonomialInf moninf = resolve_mon_exp(monexp);
 271 | 
 272 |         auto monsymbol = moninf.first;
 273 |         if (monsymbol.type == SYMBOL_TYPE::ALPHA)
 274 |         {
 275 |             monrep.resize(ini_size);
 276 |             for (auto& i : moninf.second)
 277 |             {
 278 |                 if (i < ini_size)
 279 |                     monrep[i] = 1;
 280 |                 else
 281 |                 {
 282 |                     monrep.resize(0);
 283 |                     break;
 284 |                 }
 285 |             }
 286 |         }
 287 |         else if (monsymbol.type == SYMBOL_TYPE::ONE)
 288 |         {
 289 |             monrep.resize(ini_size);
 290 |         }
 291 |         else if (monsymbol.type == SYMBOL_TYPE::ZERO)
 292 |         {
 293 |             monrep.resize(ini_size);
 294 |             coefficient = 0;
 295 |         }
 296 | 
 297 |         
 298 |         
 299 |     }
 300 | 
 301 | public:
 302 |     int size() const { return monrep.size(); } 
 303 | 
 304 |     bool isnull() const { return monrep.size() == 0; }
 305 | 
 306 |     bool iszero() const { return coefficient == 0 && monrep.size() != 0; }
 307 | 
 308 |     bool isone() const
 309 |     {
 310 |         return coefficient == 1 && monrep.none() == true;
 311 |     }
 312 | 
 313 |     void resize(int n)
 314 |     {
 315 |         monrep.resize(n);
 316 |     }
 317 | 
 318 |     dynamic_bitset<> rep() const
 319 |     {
 320 |         return monrep;
 321 |     }
 322 | 
 323 |     set<int> index() const
 324 |     {
 325 |         set<int> indexes;
 326 |         if (coefficient == 0)
 327 |             return indexes;
 328 | 
 329 |         for (int i = 0; i < monrep.size(); i++)
 330 |             if (monrep[i])
 331 |                 indexes.emplace(i);
 332 | 
 333 |         return indexes;
 334 |     }
 335 | 
 336 |     int eval(const dynamic_bitset<>& evalmap) const
 337 |     {
 338 |         if (coefficient == 0)
 339 |             return 0;
 340 | 
 341 |         if (evalmap.size() != monrep.size())
 342 |         {
 343 |             cerr << __func__ << "The size of evalmap does not match the number of variables in this monomial." << endl;
 344 |             exit(-1);
 345 |         }
 346 | 
 347 | 
 348 |         dynamic_bitset<> evalval = evalmap & monrep;
 349 | 
 350 |         if (evalval == monrep)
 351 |             return 1;
 352 |         else
 353 |             return 0;
 354 |     }
 355 | 
 356 |     int eval(const map<int, int>& evalmap) const
 357 |     {
 358 |         if (coefficient == 0)
 359 |             return 0;
 360 | 
 361 |         for (int i = 0; i < monrep.size(); i++)
 362 |         {
 363 |             if (monrep[i] == 1)
 364 |             {
 365 |                const auto & it = evalmap.find(i);
 366 |                if (it == evalmap.end())
 367 |                    return 0;
 368 |                else if (it->second == 0)
 369 |                    return 0;
 370 |             }
 371 |         }
 372 | 
 373 |         return 1;
 374 |         
 375 |     }
 376 | 
 377 |     void subs(const map<int, int>& submap) 
 378 |     {
 379 | 
 380 |         for (auto& var_val : submap)
 381 |         {
 382 |             int val = var_val.second % 2;
 383 |             int var = var_val.first;
 384 |             try
 385 |             {
 386 |                 if (var >= monrep.size())
 387 |                     throw string("The input substitute table is invalid.");
 388 |             }
 389 |             catch (string s)
 390 |             {
 391 |                 cerr << __func__<<":"<< s << endl;
 392 |                 exit(-1);
 393 |             }
 394 | 
 395 |             if(monrep[var] == 1)
 396 |                 if (val == 0)
 397 |                 {
 398 |                     monrep.reset();
 399 |                     coefficient = 0;
 400 |                 }
 401 |                 else
 402 |                 {
 403 |                     monrep[var] = 0;
 404 |                 }
 405 | 
 406 | 
 407 |         }
 408 |     }
 409 | 
 410 |     BooleanPolynomial subs(const vector<BooleanPolynomial>& submap) const;
 411 | 
 412 |    
 413 | 
 414 | 
 415 |     BooleanMonomial intersect(const dynamic_bitset<>& mask)
 416 |     {
 417 |         BooleanMonomial _res;
 418 | 
 419 |         if (mask.size() != monrep.size())
 420 |             return _res;
 421 | 
 422 |         _res.resize(monrep.size());
 423 | 
 424 |         if (coefficient == 0)
 425 |         {
 426 |             _res.coefficient = 0;
 427 |             return _res;
 428 |         }
 429 |         else
 430 |         {
 431 |             _res.monrep = monrep & mask;
 432 |             return _res;
 433 |         }
 434 | 
 435 |     }
 436 | 
 437 | 
 438 |     bool operator[] (int i) const
 439 |     {
 440 |         return monrep[i] & (coefficient != 0);
 441 |     }
 442 | 
 443 |     int count() const
 444 |     {
 445 |         if (coefficient == 0)
 446 |             return 0;
 447 | 
 448 |         return monrep.count();
 449 |     }
 450 | 
 451 |     void print(ostream& os, const char c = 's') const
 452 |     {
 453 |         // symbol is 's' by default
 454 |         int len = this->size();
 455 |         if (len == 0)
 456 |             os << "null";
 457 |         else if (coefficient == 0)
 458 |             os << "0";
 459 |         else
 460 |         {
 461 |             if (this->count() > 0)
 462 |             {
 463 |                 for (int i = 0; i < len; i++)
 464 |                     if ((*this)[i])
 465 |                         os << c << i;
 466 |             }
 467 |             else
 468 |                 os << "1";
 469 | 
 470 |         }
 471 |     }
 472 | 
 473 | 
 474 |     void operator *= (const BooleanMonomial& _mon)
 475 |     {
 476 | 
 477 |         int _size0 = this->size();
 478 |         int _size1 = _mon.size();
 479 |         if (_size0 == _size1)
 480 |         {
 481 |             if(!_mon.iszero())
 482 |                 monrep |= _mon.monrep;
 483 |             else
 484 |             {
 485 |                 coefficient = 0;
 486 |                 monrep.reset();
 487 |             }
 488 |         }
 489 |     }
 490 | 
 491 |     void operator /= (const BooleanMonomial& _mon)
 492 |     {
 493 |         if (_mon.iszero())
 494 |             return;
 495 | 
 496 |         int _size0 = this->size();
 497 |         int _size1 = _mon.size();
 498 |         if (_size0 == _size1 &&  !_mon.iszero())
 499 |         {
 500 |             auto checkflag = ((monrep & _mon.monrep) == _mon.monrep);
 501 |             if (checkflag)
 502 |                 monrep = (monrep & (~_mon.monrep));
 503 |         }
 504 |     }
 505 | 
 506 |     friend bool operator == (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 507 |     {
 508 | 
 509 |         return ((_mon0.iszero() && _mon1.iszero()) && (_mon0.size() == _mon1.size())) || 
 510 |             ( (_mon0.monrep == _mon1.monrep) && (!_mon0.iszero() && !_mon1.iszero()) );
 511 |     }
 512 | 
 513 | 
 514 |     friend bool operator != (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 515 |     {
 516 |         return !(_mon0 == _mon1);
 517 |     }
 518 | 
 519 |     friend BooleanMonomial operator * (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 520 |     {
 521 |         int _size0 = _mon0.size();
 522 |         int _size1 = _mon1.size();
 523 |         if (_size0 == _size1)
 524 |         {
 525 |             if (_mon1.iszero() || _mon0.iszero())
 526 |             {
 527 |                 return BooleanMonomial(_size0, 0);
 528 |             }
 529 |             else
 530 |             {
 531 |                 BooleanMonomial _res(_mon0);
 532 |                 _res *= _mon1;
 533 |                 return _res;
 534 |             }
 535 |         }
 536 | 
 537 |         return BooleanMonomial();
 538 |     }
 539 | 
 540 | 
 541 |     friend BooleanMonomial operator / (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 542 |     {
 543 |         int _size0 = _mon0.size();
 544 |         int _size1 = _mon1.size();
 545 |         if (_size0 == _size1 && !_mon1.iszero())
 546 |         {
 547 |             if (_mon0.iszero())
 548 |             {
 549 |                 return BooleanMonomial(_size0, 0);
 550 |             }
 551 |             else
 552 |             {
 553 |                 BooleanMonomial _res(_mon0);
 554 |                 _res /= _mon1;
 555 |                 return _res;
 556 |             }
 557 |         }
 558 | 
 559 |         return BooleanMonomial();
 560 |     }
 561 | 
 562 |     friend bool operator < (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 563 |     {
 564 |         auto _size0 = _mon0.size();
 565 |         auto _size1 = _mon1.size();
 566 |         if (_size0 < _size1)
 567 |             return true;
 568 |         else if (_size0 > _size1)
 569 |             return false;
 570 |         else
 571 |         {
 572 |             if (!_mon0.iszero() && !_mon1.iszero())
 573 |             {
 574 |                 for (int i = 0; i < _size0; i++)
 575 |                     if (_mon0[i] < _mon1[i])
 576 |                         return true;
 577 |                     else if (_mon0[i] > _mon1[i])
 578 |                         return false;
 579 | 
 580 | 
 581 |                 return false;
 582 |             }
 583 |             else if (_mon0.iszero() && !_mon1.iszero())
 584 |                 return true;
 585 |             else
 586 |                 return false;
 587 |         }
 588 |     }
 589 | 
 590 |     friend bool operator > (const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
 591 |     {
 592 |         return _mon1 < _mon0;
 593 |     }
 594 | 
 595 |     
 596 |     friend BooleanPolynomial operator +(const BooleanMonomial& _mon0, const BooleanMonomial& _mon1);
 597 | 
 598 | 
 599 |     friend ostream& operator << (ostream& os, const BooleanMonomial& mon)
 600 |     {
 601 |         mon.print(os);
 602 | 
 603 |         return os;
 604 |     }
 605 |     
 606 |     
 607 | };
 608 | 
 609 | 
 610 | 
 611 | 
 612 | 
 613 | class BooleanPolynomial
 614 | {
 615 | private:
 616 |     vector<BooleanMonomial> polyrep;
 617 | 
 618 |     char symbol = 's';
 619 | 
 620 |     int varsnum = 0;
 621 | 
 622 | 
 623 | public:
 624 |     BooleanPolynomial() {};
 625 |     BooleanPolynomial(const BooleanMonomial& mon, const char s = 's') {
 626 |         polyrep.emplace_back(mon);
 627 |         varsnum = mon.size();
 628 |         symbol = s;
 629 |     }
 630 | 
 631 | 
 632 |     BooleanPolynomial(const BooleanPolynomial& poly)
 633 |     {
 634 |         polyrep = poly.polyrep;
 635 |         varsnum = poly.varsnum;
 636 |         symbol = poly.symbol;
 637 |     }
 638 |     
 639 |     BooleanPolynomial(int ini_size, vector<dynamic_bitset<>>& mon_reps)
 640 |     {
 641 |         varsnum = ini_size;
 642 |         for (auto& mon_rep : mon_reps)
 643 |             polyrep.emplace_back(BooleanMonomial(mon_rep));
 644 |     }
 645 | 
 646 |     
 647 |     BooleanPolynomial(int ini_size, const string polyexp, const char s = 's')
 648 |     {
 649 |         if (ini_size <= 0)
 650 |             return;
 651 | 
 652 |         string exp = remove_blank(polyexp);
 653 | 
 654 |         using BooleanResolution::PolyInf;
 655 |         using BooleanResolution::resolve_poly_exp;
 656 |         using BooleanResolution::SYMBOL_TYPE;
 657 |         using BooleanResolution::SYMBOL_VALUE;
 658 | 
 659 | 
 660 |         PolyInf moninfs = resolve_poly_exp(exp);
 661 |         if (moninfs.size() == 0)
 662 |             return;
 663 | 
 664 |         
 665 |         SYMBOL_VALUE prev_symbol = '?';
 666 | 
 667 |         for (auto& moninf : moninfs)
 668 |         {
 669 |             auto& monsymbol = moninf.first;
 670 |             if (monsymbol.type == SYMBOL_TYPE::ONE)
 671 |             {
 672 |                 BooleanMonomial mon(ini_size);
 673 |                 polyrep.emplace_back(mon);
 674 |                 symbol = s;
 675 |                 continue;
 676 |             }
 677 |             else if (monsymbol.type == SYMBOL_TYPE::ZERO)
 678 |             {
 679 |                 symbol = s;
 680 |                 continue;
 681 |             }
 682 |             else
 683 |             {
 684 |                 if (prev_symbol == '?')
 685 |                     prev_symbol = monsymbol.val;
 686 |                 else
 687 |                     if (prev_symbol != monsymbol.val)
 688 |                     {
 689 |                         polyrep.clear();
 690 |                         polyrep.shrink_to_fit();
 691 |                         return;
 692 |                     }
 693 |             }
 694 | 
 695 |             BooleanMonomial mon(ini_size, moninf.second);
 696 |             if (mon.isnull())
 697 |             {
 698 |                 polyrep.clear();
 699 |                 polyrep.shrink_to_fit();
 700 |                 return;
 701 |             }
 702 |             else
 703 |             {
 704 |                 polyrep.emplace_back(mon);
 705 |             }
 706 |         }
 707 | 
 708 |         if (prev_symbol == '?')
 709 |             symbol = s;
 710 |         else
 711 |             symbol = char(prev_symbol);
 712 | 
 713 |         varsnum = ini_size;
 714 | 
 715 |         
 716 |         sort(polyrep.begin(), polyrep.end());
 717 |     }
 718 |     
 719 | 
 720 | 
 721 | 
 722 |     void resize(int n)
 723 |     {
 724 |         varsnum = n;
 725 |         for (auto& mon : polyrep)
 726 |             mon.resize(n);
 727 |     }
 728 | 
 729 |     int size() const
 730 |     {
 731 |         return varsnum;
 732 |     }
 733 | 
 734 |     int moncnt() const
 735 |     {
 736 |         return polyrep.size();
 737 |     }
 738 | 
 739 |     int deg() const
 740 |     {
 741 |         int deg = 0;
 742 |         for (auto& mon : polyrep)
 743 |             if (mon.count() > deg)
 744 |                 deg = mon.count();
 745 | 
 746 |         return deg;
 747 |     }
 748 | 
 749 |     
 750 | 
 751 |     BooleanPolynomial & emplace_back(const BooleanMonomial& mon)
 752 |     {
 753 |         if (mon.size() == varsnum)
 754 |             polyrep.emplace_back(mon);
 755 | 
 756 |         return *this;
 757 |     }
 758 | 
 759 |     void reduce()
 760 |     {
 761 |        
 762 |         map<BooleanMonomial, int> monmap;
 763 |         for (auto& mon : polyrep)
 764 |             if(!mon.iszero())
 765 |                 monmap[mon]++;
 766 | 
 767 |         polyrep.clear();
 768 |         polyrep.shrink_to_fit();
 769 |         for (auto& moncnt : monmap)
 770 |             if (moncnt.second % 2)
 771 |                 polyrep.emplace_back(moncnt.first);
 772 |         
 773 |     }
 774 | 
 775 | 
 776 | 
 777 | 
 778 |     bool iszero() const { return (polyrep.size() == 0 && varsnum != 0) || (polyrep.size() == 1 && polyrep[0].iszero()); } 
 779 | 
 780 |     bool isone() const { return polyrep.size() == 1 && polyrep[0].isone(); }
 781 | 
 782 |     bool isnull() const { return varsnum == 0; }
 783 | 
 784 |     void operator = (const BooleanMonomial& _mon)
 785 |     {
 786 |         polyrep.emplace_back(_mon);
 787 |         varsnum = _mon.size();
 788 |         symbol = 's';
 789 |     }
 790 | 
 791 |     void operator += (const BooleanMonomial& _mon)
 792 |     {
 793 |         if (varsnum != _mon.size())
 794 |             return;
 795 | 
 796 |         this->emplace_back(_mon);
 797 |         this->reduce();
 798 |     }
 799 | 
 800 |     void operator += (const BooleanPolynomial& _poly)
 801 |     {
 802 |         if (_poly.varsnum != varsnum || _poly.symbol != symbol)
 803 |             return;
 804 | 
 805 |         map<BooleanMonomial, int> monmap;
 806 |         for (auto& mon : polyrep)
 807 |             monmap[mon]++;
 808 |         for (auto& mon : _poly.polyrep)
 809 |             monmap[mon]++;
 810 | 
 811 |         polyrep.clear();
 812 |         polyrep.shrink_to_fit();
 813 |         for (auto& moncnt : monmap)
 814 |             if (moncnt.second % 2)
 815 |                 polyrep.emplace_back(moncnt.first);
 816 | 
 817 |     }
 818 | 
 819 |     void operator *= (const BooleanPolynomial& _poly)
 820 |     {
 821 |         if (_poly.varsnum != varsnum || _poly.symbol != symbol || _poly.isone())
 822 |             return;
 823 | 
 824 |         map<BooleanMonomial, int> monmap;
 825 |         for (auto& mon0 : polyrep)
 826 |             for (auto& mon1 : _poly.polyrep)
 827 |                 monmap[mon0 * mon1] ++;
 828 | 	
 829 | 	
 830 | 	    polyrep.clear();
 831 | 	    polyrep.shrink_to_fit();
 832 | 	    //cout << polyrep.capacity()<<endl;
 833 | 
 834 |         for (auto& moncnt : monmap)
 835 |             if (moncnt.second % 2)
 836 |                 polyrep.emplace_back(moncnt.first);
 837 | 
 838 |     }
 839 | 
 840 |     void operator *= (const BooleanMonomial& _mon)
 841 |     {
 842 |         if (varsnum != _mon.size() || _mon.isone())
 843 |             return;
 844 | 
 845 |         map<BooleanMonomial, int> monmap;
 846 |         for (auto& mon0 : polyrep)
 847 |             monmap[mon0 * _mon] ++;
 848 | 
 849 |         polyrep.clear();
 850 |         polyrep.shrink_to_fit();
 851 |         for (auto& moncnt : monmap)
 852 |             if (moncnt.second % 2)
 853 |                 polyrep.emplace_back(moncnt.first);
 854 | 
 855 |     }
 856 | 
 857 |     auto begin() const
 858 |     {
 859 |         return polyrep.begin();
 860 |     }
 861 | 
 862 |     auto end() const
 863 |     {
 864 |         return polyrep.end();
 865 |     }
 866 | 
 867 |     BooleanMonomial operator[] (int i) const
 868 |     {
 869 |         return polyrep[i];
 870 |     }
 871 | 
 872 |     int eval(const map<int, int>& evalmap) const
 873 |     {
 874 |         int res = 0;
 875 |         for (auto& mon : polyrep)
 876 |         {
 877 |             res ^= mon.eval(evalmap);
 878 |         }
 879 | 
 880 |         return res;
 881 |     }
 882 | 
 883 |     int eval(const dynamic_bitset<>& evalmap) const
 884 |     {
 885 |         int res = 0;
 886 |         for (auto& mon : polyrep)
 887 |         {
 888 |             res ^= mon.eval(evalmap);
 889 |         }
 890 | 
 891 |         return res;
 892 |     }
 893 | 
 894 |     void subs(const map<int, int>& submap)
 895 |     {
 896 |         for (auto& mon : polyrep)
 897 |         {
 898 |             mon.subs(submap);
 899 |         }
 900 | 
 901 |         this->reduce();
 902 |     }
 903 | 
 904 |     BooleanPolynomial subs(const vector<BooleanPolynomial>& submap) const
 905 |     {
 906 | 
 907 |         vector<BooleanPolynomial> sum_mons;
 908 |         for (auto& mon : polyrep)
 909 |         {
 910 |             auto part_res = mon.subs(submap);
 911 |             sum_mons.emplace_back(part_res);
 912 |         }
 913 |         return fastsum(varsnum, sum_mons);
 914 |     }
 915 | 
 916 | 
 917 |     
 918 |     friend BooleanPolynomial operator + (const BooleanPolynomial& _poly0, const BooleanPolynomial& _poly1)
 919 |     {
 920 |         BooleanPolynomial _res;
 921 |         if (_poly0.symbol != _poly1.symbol)
 922 |             return _res;
 923 |         int _size0 = _poly0.size();
 924 |         int _size1 = _poly1.size();
 925 |         if (_size0 == _size1)
 926 |         {
 927 |             _res = _poly0;
 928 |             _res += _poly1;
 929 |         }
 930 |         return _res;
 931 |     }
 932 | 
 933 |     friend BooleanPolynomial fastsum(int varsnum, const vector<BooleanPolynomial>& polys)
 934 |     {
 935 |         BooleanPolynomial _res;
 936 |         _res.varsnum = varsnum;
 937 |         if (polys.size() == 0)
 938 |             return _res;
 939 | 
 940 |         _res.symbol = polys[0].symbol;
 941 | 
 942 | 
 943 | 
 944 |         map<BooleanMonomial, int> monmap;
 945 |         for (auto& poly : polys)
 946 |             for (auto& mon : poly.polyrep)
 947 |                 monmap[mon]++;
 948 |         
 949 |         for (auto& moncnt : monmap)
 950 |             if (moncnt.second % 2)
 951 |                 _res.polyrep.emplace_back(moncnt.first);
 952 | 
 953 | 
 954 |         return _res;
 955 |     }
 956 | 
 957 |     friend BooleanPolynomial fastmul(int varsnum, const set<BooleanPolynomial>& polys)
 958 |     {
 959 |         BooleanMonomial mon_1(varsnum);
 960 |         BooleanPolynomial _res(mon_1);
 961 |         if (polys.size() == 0)
 962 |             return _res;
 963 | 
 964 |         auto cur_res = polys;
 965 | 
 966 |         while (cur_res.size() != 1)
 967 |         {
 968 |             auto& first_poly = (*cur_res.begin());
 969 |             if (first_poly.iszero())
 970 |             {
 971 |                 _res.polyrep.clear();
 972 |                 //_res.polyrep.shrink_to_fit();
 973 |                 return _res;
 974 |             }
 975 | 
 976 |             set<BooleanPolynomial> next_res;
 977 |             auto it0 = cur_res.begin();
 978 |             auto it1 = cur_res.rbegin();
 979 |             while ((*it0) < (*it1))
 980 |             {
 981 |                 auto new_poly = (*it0) * (*it1);
 982 |                 next_res.emplace(new_poly);
 983 | 
 984 |                 it0++;
 985 |                 it1++;
 986 |             }
 987 | 
 988 |             if ((*it0) == (*it1))
 989 |                 next_res.emplace(*it0);
 990 | 
 991 |             cur_res = next_res;
 992 |         }
 993 | 
 994 |         _res = (*cur_res.begin());
 995 |         return _res;
 996 |     }
 997 | 
 998 |     friend BooleanPolynomial fastmul(int varsnum, const vector<BooleanPolynomial>& polys)
 999 |     {
1000 |         set<BooleanPolynomial> polysSet(polys.begin(), polys.end());
1001 | 
1002 |         return fastmul(varsnum, polysSet);
1003 |     }
1004 | 
1005 | 
1006 |     friend BooleanPolynomial operator * (const BooleanPolynomial& _poly0, const BooleanPolynomial&  _poly1)
1007 |     {
1008 |         BooleanPolynomial _res;
1009 |         if (_poly0.symbol != _poly1.symbol)
1010 |             return _res;
1011 |         int _size0 = _poly0.size();
1012 |         int _size1 = _poly1.size();
1013 |         if (_size0 == _size1)
1014 |         {
1015 |             _res = _poly0;
1016 |             _res *= _poly1;
1017 |         }
1018 |         return _res;
1019 |     }
1020 | 
1021 |     friend bool operator < (const BooleanPolynomial& _poly0, const BooleanPolynomial& _poly1)
1022 |     {
1023 |         try
1024 |         {
1025 |             if (_poly0.symbol != _poly1.symbol || _poly0.size() != _poly1.size())
1026 |             {
1027 |                 throw string("Try to compare two polynomials with different symbols or variables");
1028 |             }
1029 |         }
1030 |         catch(string s)
1031 |         {
1032 |             cerr << __func__ << ":" << s << endl;
1033 |             exit(1);
1034 |         }
1035 |         int _cnt0 = _poly0.moncnt();
1036 |         int _cnt1 = _poly1.moncnt();
1037 |         if (_cnt0 < _cnt1)
1038 |             return true;
1039 |         else if (_cnt0 > _cnt1)
1040 |             return false;
1041 |         else
1042 |         {
1043 |             for (int i = 0; i < _cnt0; i++)
1044 |             {
1045 |                 if (_poly0[i] < _poly1[i])
1046 |                     return true;
1047 |                 else if (_poly0[i] > _poly1[i])
1048 |                     return false;
1049 |                 
1050 |             }
1051 | 
1052 |             return false;
1053 |         }
1054 |     }
1055 | 
1056 |     friend bool operator > (const BooleanPolynomial& _poly0, const BooleanPolynomial& _poly1)
1057 |     {
1058 |         return _poly1 < _poly0;
1059 |     }
1060 | 
1061 |     friend bool operator ==(const BooleanPolynomial& _poly0, const BooleanPolynomial& _poly1)
1062 |     {
1063 |         try
1064 |         {
1065 |             if (_poly0.symbol != _poly1.symbol || _poly0.size() != _poly1.size())
1066 |             {
1067 |                 throw string("Try to compare two polynomials with different symbols or variables");
1068 |             }
1069 |         }
1070 |         catch (string s)
1071 |         {
1072 |             cerr << __func__ << ":" << s << endl;
1073 |             exit(1);
1074 |         }
1075 | 
1076 |         int _cnt0 = _poly0.moncnt();
1077 |         int _cnt1 = _poly1.moncnt();
1078 |         if (_cnt0 != _cnt1)
1079 |             return false;
1080 | 
1081 |         for (int i = 0; i < _cnt0; i++)
1082 |             if (_poly0[i] != _poly1[i])
1083 |                 return false;
1084 |         return true;
1085 |     }
1086 | 
1087 |     friend bool operator !=(const BooleanPolynomial& _poly0, const BooleanPolynomial& _poly1)
1088 |     {
1089 |         return !(_poly0 == _poly1);
1090 |     }
1091 | 
1092 | 
1093 |     friend ostream& operator << (ostream& os, const BooleanPolynomial& poly)
1094 |     {
1095 |         // symbol is 's' by default
1096 |         if (poly.size() == 0)
1097 |             os << "null";
1098 |         else if (poly.iszero())
1099 |             os << "0";
1100 |         else
1101 |         {
1102 |             string sep = "";
1103 |             for (auto& mon : poly.polyrep)
1104 |             {
1105 |                 os << sep;
1106 |                 mon.print(os, poly.symbol);
1107 |                 sep = "+";
1108 |             }
1109 | 
1110 |         }
1111 | 
1112 |         return os;
1113 |     }
1114 | 
1115 | };
1116 | 
1117 | 
1118 | 
1119 | // 
1120 | BooleanPolynomial operator +(const BooleanMonomial& _mon0, const BooleanMonomial& _mon1)
1121 | {
1122 |     BooleanPolynomial _res;
1123 |     auto _size0 = _mon0.size();
1124 |     auto _size1 = _mon1.size();
1125 |     if (_size0 == _size1)
1126 |     {
1127 |         _res.resize(_size0);
1128 |         if (_mon0 != _mon1)
1129 |             (_res.emplace_back(_mon0)).emplace_back(_mon1);
1130 |     }
1131 | 
1132 |     _res.reduce();
1133 | 
1134 |     return _res;
1135 | 
1136 | }
1137 | 
1138 | BooleanPolynomial BooleanMonomial::subs(const vector<BooleanPolynomial>& submap) const
1139 | {
1140 |     if (monrep.size() != submap.size())
1141 |     {
1142 |         cerr << __func__ << ":" << "The input substitute table is invalid." << endl;
1143 |         cerr << "Monrep size: " << monrep.size() << endl;
1144 |         cerr << "Submap size: " << submap.size() << endl;
1145 |         exit(-1);
1146 |     }
1147 | 
1148 |     BooleanPolynomial res(monrep.size(), "1");
1149 | 
1150 |     for (auto& i : this->index())
1151 |         res *= submap[i];
1152 | 
1153 | 
1154 |     return res;
1155 | 
1156 | }
1157 | 
1158 | #endif
1159 | 


--------------------------------------------------------------------------------
/KreyviumSuperpoly/899_I3.txt:
--------------------------------------------------------------------------------
   1 | 1
   2 | s126
   3 | s124
   4 | s121s122
   5 | s119s122
   6 | s118
   7 | s117
   8 | s115s124
   9 | s114
  10 | s114s124
  11 | s114s122
  12 | s113s124
  13 | s113s122
  14 | s113s114
  15 | s113s114s124
  16 | s113s114s122
  17 | s112
  18 | s111s112
  19 | s110
  20 | s110s111
  21 | s106
  22 | s105
  23 | s105s122
  24 | s104
  25 | s103
  26 | s103s122
  27 | s100
  28 | s99
  29 | s98
  30 | s98s121
  31 | s98s119
  32 | s98s115
  33 | s98s105
  34 | s98s104
  35 | s98s103
  36 | s97s123
  37 | s97s119
  38 | s97s114
  39 | s97s113
  40 | s97s113s114
  41 | s97s105
  42 | s97s103
  43 | s96s124
  44 | s96s121
  45 | s96s112
  46 | s96s102
  47 | s95
  48 | s95s124
  49 | s95s96
  50 | s94s96
  51 | s93s122
  52 | s93s98
  53 | s93s97
  54 | s92s122
  55 | s92s97
  56 | s91s126
  57 | s91s115
  58 | s91s115s122
  59 | s91s114
  60 | s91s114s122
  61 | s91s113
  62 | s91s113s122
  63 | s91s113s114
  64 | s91s113s114s122
  65 | s91s103
  66 | s91s98s115
  67 | s91s98s114
  68 | s91s98s113
  69 | s91s98s113s114
  70 | s91s97s115
  71 | s91s97s114
  72 | s91s97s113
  73 | s91s97s113s114
  74 | s91s96
  75 | s90
  76 | s90s124
  77 | s90s122
  78 | s90s115s122
  79 | s90s114s122
  80 | s90s113s122
  81 | s90s113s114s122
  82 | s90s103s122
  83 | s90s98s115
  84 | s90s98s114
  85 | s90s98s113
  86 | s90s98s113s114
  87 | s90s98s103
  88 | s90s97
  89 | s90s97s115
  90 | s90s97s114
  91 | s90s97s113
  92 | s90s97s113s114
  93 | s90s97s103
  94 | s90s94
  95 | s90s93
  96 | s90s93s122
  97 | s90s93s98
  98 | s90s93s97
  99 | s90s91
 100 | s90s91s98
 101 | s89s126
 102 | s89s124
 103 | s89s122
 104 | s89s115s122
 105 | s89s114s122
 106 | s89s113s122
 107 | s89s113s114s122
 108 | s89s98
 109 | s89s98s115
 110 | s89s98s114
 111 | s89s98s113
 112 | s89s98s113s114
 113 | s89s97
 114 | s89s97s115
 115 | s89s97s114
 116 | s89s97s113
 117 | s89s97s113s114
 118 | s89s93
 119 | s89s91
 120 | s89s90
 121 | s89s90s115
 122 | s89s90s114
 123 | s89s90s113
 124 | s89s90s113s114
 125 | s89s90s103
 126 | s89s90s98
 127 | s89s90s96
 128 | s88
 129 | s88s124
 130 | s88s98
 131 | s88s91
 132 | s88s91s122
 133 | s88s91s98
 134 | s88s91s97
 135 | s88s90s122
 136 | s88s90s98
 137 | s88s90s97
 138 | s88s89s122
 139 | s88s89s115
 140 | s88s89s113s114
 141 | s88s89s112
 142 | s88s89s112s113
 143 | s88s89s91
 144 | s88s89s91s122
 145 | s88s89s91s98
 146 | s88s89s91s97
 147 | s88s89s90s122
 148 | s88s89s90s98
 149 | s88s89s90s97
 150 | s87s89
 151 | s87s88
 152 | s87s88s89
 153 | s86s115
 154 | s86s114
 155 | s86s113
 156 | s86s113s114
 157 | s86s99
 158 | s86s96
 159 | s86s91
 160 | s86s89
 161 | s86s89s90
 162 | s86s88
 163 | s85
 164 | s84s85
 165 | s84s85s115
 166 | s84s85s114
 167 | s84s85s113
 168 | s84s85s113s114
 169 | s84s85s99
 170 | s84s85s89
 171 | s84s85s88
 172 | s83s104
 173 | s83s96
 174 | s83s84
 175 | s82s122
 176 | s82s104
 177 | s82s102
 178 | s82s98
 179 | s82s97
 180 | s82s91
 181 | s82s90
 182 | s82s89s90
 183 | s82s83
 184 | s81s122
 185 | s81s98
 186 | s81s97
 187 | s81s96
 188 | s81s91
 189 | s81s90
 190 | s81s89
 191 | s81s82
 192 | s81s82s104
 193 | s80
 194 | s80s122
 195 | s80s97
 196 | s80s90s122
 197 | s80s90s98
 198 | s80s90s97
 199 | s80s89
 200 | s80s88
 201 | s80s81
 202 | s80s81s122
 203 | s80s81s104
 204 | s80s81s98
 205 | s80s81s97
 206 | s80s81s91
 207 | s80s81s90
 208 | s80s81s89s90
 209 | s79s98
 210 | s79s96
 211 | s79s90
 212 | s79s90s122
 213 | s79s90s98
 214 | s79s90s97
 215 | s79s88s89
 216 | s79s85
 217 | s79s83s84
 218 | s79s80s122
 219 | s79s80s98
 220 | s79s80s97
 221 | s79s80s96
 222 | s79s80s90
 223 | s78
 224 | s78s122
 225 | s78s115s122
 226 | s78s114s122
 227 | s78s113s122
 228 | s78s113s114s122
 229 | s78s98
 230 | s78s98s115
 231 | s78s98s114
 232 | s78s98s113
 233 | s78s98s113s114
 234 | s78s97s115
 235 | s78s97s114
 236 | s78s97s113
 237 | s78s97s113s114
 238 | s78s96
 239 | s78s90s122
 240 | s78s90s98
 241 | s78s90s97
 242 | s78s88s122
 243 | s78s88s98
 244 | s78s88s97
 245 | s78s79s89
 246 | s78s79s88
 247 | s77s122
 248 | s77s98
 249 | s77s97
 250 | s77s96
 251 | s77s91
 252 | s77s78s122
 253 | s77s78s97
 254 | s77s78s85
 255 | s77s78s83s84
 256 | s76
 257 | s76s78
 258 | s76s77s122
 259 | s76s77s115s122
 260 | s76s77s114s122
 261 | s76s77s113s122
 262 | s76s77s113s114s122
 263 | s76s77s98
 264 | s76s77s98s115
 265 | s76s77s98s114
 266 | s76s77s98s113
 267 | s76s77s98s113s114
 268 | s76s77s97
 269 | s76s77s97s115
 270 | s76s77s97s114
 271 | s76s77s97s113
 272 | s76s77s97s113s114
 273 | s76s77s90s122
 274 | s76s77s90s98
 275 | s76s77s90s97
 276 | s76s77s88s122
 277 | s76s77s88s98
 278 | s76s77s88s97
 279 | s76s77s79s122
 280 | s76s77s79s98
 281 | s76s77s79s97
 282 | s76s77s79s90s122
 283 | s76s77s79s90s98
 284 | s76s77s79s90s97
 285 | s76s77s78s122
 286 | s76s77s78s98
 287 | s76s77s78s97
 288 | s76s77s78s90s122
 289 | s76s77s78s90s98
 290 | s76s77s78s90s97
 291 | s75s76
 292 | s75s76s122
 293 | s75s76s98
 294 | s75s76s97
 295 | s73s103s122
 296 | s73s100
 297 | s73s99
 298 | s73s98s103
 299 | s73s97
 300 | s73s97s103
 301 | s73s94
 302 | s73s93
 303 | s73s93s122
 304 | s73s93s98
 305 | s73s93s97
 306 | s73s92
 307 | s73s91s122
 308 | s73s91s98
 309 | s73s91s97
 310 | s73s90
 311 | s73s90s122
 312 | s73s90s98
 313 | s73s90s97
 314 | s73s90s91
 315 | s73s89
 316 | s73s89s122
 317 | s73s89s98
 318 | s73s89s97
 319 | s73s88
 320 | s73s86
 321 | s73s84s85
 322 | s73s80s122
 323 | s73s80s98
 324 | s73s80s97
 325 | s73s79s91s122
 326 | s73s79s91s98
 327 | s73s79s91s97
 328 | s73s79s90s122
 329 | s73s79s90s98
 330 | s73s79s90s97
 331 | s73s79s89s122
 332 | s73s79s89s98
 333 | s73s79s89s97
 334 | s73s78s122
 335 | s73s78s98
 336 | s73s78s97
 337 | s73s77s78s122
 338 | s73s77s78s98
 339 | s73s77s78s97
 340 | s73s77s78s91s122
 341 | s73s77s78s91s98
 342 | s73s77s78s91s97
 343 | s73s77s78s90s122
 344 | s73s77s78s90s98
 345 | s73s77s78s90s97
 346 | s73s77s78s89s122
 347 | s73s77s78s89s98
 348 | s73s77s78s89s97
 349 | s73s76s77s122
 350 | s73s76s77s98
 351 | s73s76s77s97
 352 | s73s76s77s79s122
 353 | s73s76s77s79s98
 354 | s73s76s77s79s97
 355 | s73s76s77s78s122
 356 | s73s76s77s78s98
 357 | s73s76s77s78s97
 358 | s72
 359 | s72s73
 360 | s71s72s103s122
 361 | s71s72s100
 362 | s71s72s99
 363 | s71s72s98
 364 | s71s72s98s103
 365 | s71s72s97
 366 | s71s72s97s103
 367 | s71s72s94
 368 | s71s72s93
 369 | s71s72s93s122
 370 | s71s72s93s98
 371 | s71s72s93s97
 372 | s71s72s92
 373 | s71s72s91s122
 374 | s71s72s91s98
 375 | s71s72s91s97
 376 | s71s72s90
 377 | s71s72s90s122
 378 | s71s72s90s98
 379 | s71s72s90s97
 380 | s71s72s90s91
 381 | s71s72s89
 382 | s71s72s89s122
 383 | s71s72s89s98
 384 | s71s72s89s97
 385 | s71s72s88
 386 | s71s72s86
 387 | s71s72s84s85
 388 | s71s72s80s122
 389 | s71s72s80s98
 390 | s71s72s80s97
 391 | s71s72s79s91s122
 392 | s71s72s79s91s98
 393 | s71s72s79s91s97
 394 | s71s72s79s90s122
 395 | s71s72s79s90s98
 396 | s71s72s79s90s97
 397 | s71s72s79s89s122
 398 | s71s72s79s89s98
 399 | s71s72s79s89s97
 400 | s71s72s78s122
 401 | s71s72s78s98
 402 | s71s72s78s97
 403 | s71s72s77s78s122
 404 | s71s72s77s78s98
 405 | s71s72s77s78s97
 406 | s71s72s77s78s91s122
 407 | s71s72s77s78s91s98
 408 | s71s72s77s78s91s97
 409 | s71s72s77s78s90s122
 410 | s71s72s77s78s90s98
 411 | s71s72s77s78s90s97
 412 | s71s72s77s78s89s122
 413 | s71s72s77s78s89s98
 414 | s71s72s77s78s89s97
 415 | s71s72s76s77s122
 416 | s71s72s76s77s98
 417 | s71s72s76s77s97
 418 | s71s72s76s77s79s122
 419 | s71s72s76s77s79s98
 420 | s71s72s76s77s79s97
 421 | s71s72s76s77s78s122
 422 | s71s72s76s77s78s98
 423 | s71s72s76s77s78s97
 424 | s71s72s73
 425 | s70s99
 426 | s70s98
 427 | s70s97
 428 | s70s96
 429 | s70s92
 430 | s70s92s98
 431 | s70s90s98
 432 | s70s90s91
 433 | s70s90s91s98
 434 | s70s88s89
 435 | s70s88s89s98
 436 | s70s79
 437 | s70s73
 438 | s70s71
 439 | s70s71s72
 440 | s69
 441 | s69s90
 442 | s69s89
 443 | s69s88s89
 444 | s69s87
 445 | s69s73
 446 | s69s71s72
 447 | s68
 448 | s68s125
 449 | s68s124
 450 | s68s122
 451 | s68s120
 452 | s68s115
 453 | s68s114
 454 | s68s113
 455 | s68s113s114
 456 | s68s99
 457 | s68s96
 458 | s68s92
 459 | s68s92s98
 460 | s68s90s91
 461 | s68s90s91s98
 462 | s68s88
 463 | s68s81
 464 | s68s79
 465 | s68s79s80
 466 | s68s69s96
 467 | s67
 468 | s67s115
 469 | s67s114
 470 | s67s113
 471 | s67s113s114
 472 | s67s96
 473 | s67s91
 474 | s67s89
 475 | s67s88
 476 | s67s70
 477 | s67s70s98
 478 | s67s68s98
 479 | s66s115
 480 | s66s114
 481 | s66s113
 482 | s66s113s114
 483 | s66s98
 484 | s66s97
 485 | s66s90
 486 | s66s89s90
 487 | s66s88
 488 | s66s82
 489 | s66s80
 490 | s66s78s79
 491 | s66s73
 492 | s66s71s72
 493 | s66s70s98
 494 | s66s68
 495 | s66s68s98
 496 | s66s67s98
 497 | s65
 498 | s65s124
 499 | s65s122
 500 | s65s98
 501 | s65s97
 502 | s65s96
 503 | s65s95
 504 | s65s91s122
 505 | s65s91s98
 506 | s65s91s97
 507 | s65s90
 508 | s65s89
 509 | s65s89s122
 510 | s65s89s98
 511 | s65s89s97
 512 | s65s88s89
 513 | s65s86
 514 | s65s84s85
 515 | s65s78s122
 516 | s65s78s98
 517 | s65s78s97
 518 | s65s76s77s122
 519 | s65s76s77s98
 520 | s65s76s77s97
 521 | s65s73
 522 | s65s73s122
 523 | s65s73s98
 524 | s65s73s97
 525 | s65s71s72
 526 | s65s71s72s122
 527 | s65s71s72s98
 528 | s65s71s72s97
 529 | s65s70
 530 | s65s70s98
 531 | s65s68
 532 | s65s68s98
 533 | s65s67
 534 | s65s66s115
 535 | s65s66s114
 536 | s65s66s113
 537 | s65s66s113s114
 538 | s65s66s98
 539 | s65s66s96
 540 | s65s66s88
 541 | s65s66s70
 542 | s65s66s70s98
 543 | s65s66s68s98
 544 | s64
 545 | s64s122
 546 | s64s115
 547 | s64s114
 548 | s64s113
 549 | s64s113s114
 550 | s64s103
 551 | s64s96
 552 | s64s90
 553 | s64s90s122
 554 | s64s90s98
 555 | s64s90s97
 556 | s64s89
 557 | s64s88
 558 | s64s88s89s122
 559 | s64s88s89s98
 560 | s64s88s89s97
 561 | s64s86
 562 | s64s82
 563 | s64s80s81
 564 | s64s66
 565 | s64s65s115
 566 | s64s65s114
 567 | s64s65s113
 568 | s64s65s113s114
 569 | s64s65s98
 570 | s64s65s97
 571 | s64s65s90
 572 | s64s65s89s90
 573 | s64s65s88
 574 | s64s65s82
 575 | s64s65s80
 576 | s64s65s78s79
 577 | s64s65s73
 578 | s64s65s71s72
 579 | s64s65s70s98
 580 | s64s65s68s98
 581 | s64s65s67
 582 | s64s65s67s98
 583 | s63s121
 584 | s63s119
 585 | s63s115
 586 | s63s114
 587 | s63s113
 588 | s63s112
 589 | s63s112s113
 590 | s63s105
 591 | s63s103
 592 | s63s98
 593 | s63s97
 594 | s63s93
 595 | s63s92
 596 | s63s91s122
 597 | s63s91s115
 598 | s63s91s114
 599 | s63s91s113
 600 | s63s91s113s114
 601 | s63s91s98
 602 | s63s91s97
 603 | s63s90
 604 | s63s90s115
 605 | s63s90s114
 606 | s63s90s113
 607 | s63s90s113s114
 608 | s63s90s103
 609 | s63s90s93
 610 | s63s89
 611 | s63s89s115
 612 | s63s89s114
 613 | s63s89s113
 614 | s63s89s113s114
 615 | s63s89s90s122
 616 | s63s89s90s98
 617 | s63s89s90s97
 618 | s63s88
 619 | s63s88s91
 620 | s63s88s90
 621 | s63s88s89
 622 | s63s88s89s91
 623 | s63s88s89s90
 624 | s63s87
 625 | s63s82
 626 | s63s81
 627 | s63s80
 628 | s63s80s90
 629 | s63s80s81
 630 | s63s79
 631 | s63s79s90
 632 | s63s79s80
 633 | s63s78
 634 | s63s78s115
 635 | s63s78s114
 636 | s63s78s113
 637 | s63s78s113s114
 638 | s63s78s90
 639 | s63s78s88
 640 | s63s77
 641 | s63s77s78
 642 | s63s76s77
 643 | s63s76s77s115
 644 | s63s76s77s114
 645 | s63s76s77s113
 646 | s63s76s77s113s114
 647 | s63s76s77s90
 648 | s63s76s77s88
 649 | s63s76s77s79
 650 | s63s76s77s79s90
 651 | s63s76s77s78
 652 | s63s76s77s78s90
 653 | s63s75s76
 654 | s63s73s103
 655 | s63s73s93
 656 | s63s73s91
 657 | s63s73s90
 658 | s63s73s89
 659 | s63s73s80
 660 | s63s73s79s91
 661 | s63s73s79s90
 662 | s63s73s79s89
 663 | s63s73s78
 664 | s63s73s77s78
 665 | s63s73s77s78s91
 666 | s63s73s77s78s90
 667 | s63s73s77s78s89
 668 | s63s73s76s77
 669 | s63s73s76s77s79
 670 | s63s73s76s77s78
 671 | s63s71s72s103
 672 | s63s71s72s93
 673 | s63s71s72s91
 674 | s63s71s72s90
 675 | s63s71s72s89
 676 | s63s71s72s80
 677 | s63s71s72s79s91
 678 | s63s71s72s79s90
 679 | s63s71s72s79s89
 680 | s63s71s72s78
 681 | s63s71s72s77s78
 682 | s63s71s72s77s78s91
 683 | s63s71s72s77s78s90
 684 | s63s71s72s77s78s89
 685 | s63s71s72s76s77
 686 | s63s71s72s76s77s79
 687 | s63s71s72s76s77s78
 688 | s63s70
 689 | s63s70s98
 690 | s63s69
 691 | s63s68
 692 | s63s65s91
 693 | s63s65s89
 694 | s63s65s78
 695 | s63s65s76s77
 696 | s63s65s73
 697 | s63s65s71s72
 698 | s63s64s124
 699 | s63s64s122
 700 | s63s64s115
 701 | s63s64s114
 702 | s63s64s113
 703 | s63s64s113s114
 704 | s63s64s97
 705 | s63s64s91
 706 | s63s64s91s122
 707 | s63s64s91s98
 708 | s63s64s91s97
 709 | s63s64s90
 710 | s63s64s89
 711 | s63s64s89s122
 712 | s63s64s89s98
 713 | s63s64s89s97
 714 | s63s64s88
 715 | s63s64s86
 716 | s63s64s84s85
 717 | s63s64s78
 718 | s63s64s78s122
 719 | s63s64s78s98
 720 | s63s64s78s97
 721 | s63s64s76s77
 722 | s63s64s76s77s122
 723 | s63s64s76s77s98
 724 | s63s64s76s77s97
 725 | s63s64s73
 726 | s63s64s73s122
 727 | s63s64s73s98
 728 | s63s64s73s97
 729 | s63s64s71s72
 730 | s63s64s71s72s122
 731 | s63s64s71s72s98
 732 | s63s64s71s72s97
 733 | s63s64s68
 734 | s63s64s67
 735 | s63s64s66
 736 | s63s64s65s66
 737 | s62
 738 | s62s122
 739 | s62s98
 740 | s62s96
 741 | s62s63s88s89
 742 | s61
 743 | s61s73
 744 | s61s71s72
 745 | s61s68
 746 | s61s62
 747 | s60s122
 748 | s60s98
 749 | s60s97
 750 | s60s63
 751 | s60s61
 752 | s59
 753 | s59s115
 754 | s59s114
 755 | s59s113
 756 | s59s113s114
 757 | s59s99
 758 | s59s89
 759 | s59s88
 760 | s59s73
 761 | s59s71s72
 762 | s59s65
 763 | s59s63s64
 764 | s58
 765 | s58s79
 766 | s58s77s78
 767 | s57s91
 768 | s57s90
 769 | s57s89
 770 | s57s88s89
 771 | s57s63
 772 | s57s58
 773 | s56
 774 | s56s124
 775 | s56s104
 776 | s56s98
 777 | s56s91
 778 | s56s91s122
 779 | s56s91s98
 780 | s56s91s97
 781 | s56s90
 782 | s56s90s122
 783 | s56s90s98
 784 | s56s90s97
 785 | s56s89s122
 786 | s56s89s98
 787 | s56s89s97
 788 | s56s89s90
 789 | s56s86
 790 | s56s84s85
 791 | s56s78s122
 792 | s56s78s98
 793 | s56s78s97
 794 | s56s76s77s122
 795 | s56s76s77s98
 796 | s56s76s77s97
 797 | s56s73
 798 | s56s71s72
 799 | s56s67
 800 | s56s66
 801 | s56s65s66
 802 | s56s64
 803 | s56s64s65
 804 | s56s63s91
 805 | s56s63s90
 806 | s56s63s89
 807 | s56s63s78
 808 | s56s63s76s77
 809 | s56s63s64
 810 | s56s59
 811 | s55s125
 812 | s55s122
 813 | s55s120
 814 | s55s113
 815 | s55s113s124
 816 | s55s113s122
 817 | s55s104
 818 | s55s101
 819 | s55s100
 820 | s55s99s100
 821 | s55s97s113
 822 | s55s96
 823 | s55s95
 824 | s55s92s98
 825 | s55s91s122
 826 | s55s91s113
 827 | s55s91s113s122
 828 | s55s91s98
 829 | s55s91s98s113
 830 | s55s91s97
 831 | s55s91s97s113
 832 | s55s90s122
 833 | s55s90s113s122
 834 | s55s90s98
 835 | s55s90s98s113
 836 | s55s90s97
 837 | s55s90s97s113
 838 | s55s90s91
 839 | s55s90s91s98
 840 | s55s89s122
 841 | s55s89s113s122
 842 | s55s89s98
 843 | s55s89s98s113
 844 | s55s89s97
 845 | s55s89s97s113
 846 | s55s89s90s113
 847 | s55s88
 848 | s55s88s89s113
 849 | s55s86
 850 | s55s86s113
 851 | s55s84s85
 852 | s55s84s85s113
 853 | s55s81
 854 | s55s79
 855 | s55s79s80
 856 | s55s78s122
 857 | s55s78s113s122
 858 | s55s78s98
 859 | s55s78s98s113
 860 | s55s78s97
 861 | s55s78s97s113
 862 | s55s76s77s122
 863 | s55s76s77s113s122
 864 | s55s76s77s98
 865 | s55s76s77s98s113
 866 | s55s76s77s97
 867 | s55s76s77s97s113
 868 | s55s74
 869 | s55s68s113
 870 | s55s67s113
 871 | s55s67s98
 872 | s55s66s113
 873 | s55s66s98
 874 | s55s65s98
 875 | s55s65s66s113
 876 | s55s65s66s98
 877 | s55s64s113
 878 | s55s64s65
 879 | s55s64s65s113
 880 | s55s64s65s98
 881 | s55s63
 882 | s55s63s91
 883 | s55s63s91s113
 884 | s55s63s90
 885 | s55s63s90s113
 886 | s55s63s89
 887 | s55s63s89s113
 888 | s55s63s78
 889 | s55s63s78s113
 890 | s55s63s76s77
 891 | s55s63s76s77s113
 892 | s55s63s64
 893 | s55s63s64s113
 894 | s55s61
 895 | s55s59
 896 | s55s59s113
 897 | s55s56s90
 898 | s55s56s88s89
 899 | s55s56s63
 900 | s54
 901 | s54s124
 902 | s54s122
 903 | s54s115s122
 904 | s54s114
 905 | s54s114s124
 906 | s54s114s122
 907 | s54s113s122
 908 | s54s113s114s122
 909 | s54s98
 910 | s54s98s115
 911 | s54s98s113
 912 | s54s98s113s114
 913 | s54s97s115
 914 | s54s97s114
 915 | s54s97s113
 916 | s54s97s113s114
 917 | s54s96
 918 | s54s92
 919 | s54s91s122
 920 | s54s91s114
 921 | s54s91s114s122
 922 | s54s91s98
 923 | s54s91s98s114
 924 | s54s91s97
 925 | s54s91s97s114
 926 | s54s90
 927 | s54s90s122
 928 | s54s90s114s122
 929 | s54s90s98
 930 | s54s90s98s114
 931 | s54s90s97
 932 | s54s90s97s114
 933 | s54s90s91
 934 | s54s89s114s122
 935 | s54s89s98s114
 936 | s54s89s97s114
 937 | s54s89s90s114
 938 | s54s88s122
 939 | s54s88s98
 940 | s54s88s97
 941 | s54s88s89s114
 942 | s54s88s89s112
 943 | s54s86
 944 | s54s86s114
 945 | s54s84s85
 946 | s54s84s85s114
 947 | s54s82
 948 | s54s80
 949 | s54s80s98
 950 | s54s80s81
 951 | s54s78s122
 952 | s54s78s114s122
 953 | s54s78s98
 954 | s54s78s98s114
 955 | s54s78s97
 956 | s54s78s97s114
 957 | s54s76s77s122
 958 | s54s76s77s114s122
 959 | s54s76s77s98
 960 | s54s76s77s98s114
 961 | s54s76s77s97
 962 | s54s76s77s97s114
 963 | s54s73
 964 | s54s73s122
 965 | s54s73s98
 966 | s54s73s97
 967 | s54s73s79s122
 968 | s54s73s79s98
 969 | s54s73s79s97
 970 | s54s73s77s78s122
 971 | s54s73s77s78s98
 972 | s54s73s77s78s97
 973 | s54s71s72
 974 | s54s71s72s122
 975 | s54s71s72s98
 976 | s54s71s72s97
 977 | s54s71s72s79s122
 978 | s54s71s72s79s98
 979 | s54s71s72s79s97
 980 | s54s71s72s77s78s122
 981 | s54s71s72s77s78s98
 982 | s54s71s72s77s78s97
 983 | s54s69
 984 | s54s68s114
 985 | s54s67s114
 986 | s54s66s114
 987 | s54s65
 988 | s54s65s122
 989 | s54s65s98
 990 | s54s65s97
 991 | s54s65s66s114
 992 | s54s64s114
 993 | s54s64s65s114
 994 | s54s63
 995 | s54s63s115
 996 | s54s63s113
 997 | s54s63s113s114
 998 | s54s63s112
 999 | s54s63s91
1000 | s54s63s91s114
1001 | s54s63s90
1002 | s54s63s90s114
1003 | s54s63s89s114
1004 | s54s63s88
1005 | s54s63s78
1006 | s54s63s78s114
1007 | s54s63s76s77
1008 | s54s63s76s77s114
1009 | s54s63s73
1010 | s54s63s73s79
1011 | s54s63s73s77s78
1012 | s54s63s71s72
1013 | s54s63s71s72s79
1014 | s54s63s71s72s77s78
1015 | s54s63s65
1016 | s54s63s64s122
1017 | s54s63s64s114
1018 | s54s63s64s98
1019 | s54s63s64s97
1020 | s54s59
1021 | s54s59s114
1022 | s54s56s122
1023 | s54s56s98
1024 | s54s56s97
1025 | s54s56s63
1026 | s54s55s124
1027 | s54s55s122
1028 | s54s55s113s122
1029 | s54s55s98s113
1030 | s54s55s97
1031 | s54s55s97s113
1032 | s54s55s91
1033 | s54s55s91s122
1034 | s54s55s91s98
1035 | s54s55s91s97
1036 | s54s55s90
1037 | s54s55s90s122
1038 | s54s55s90s98
1039 | s54s55s90s97
1040 | s54s55s89s122
1041 | s54s55s89s98
1042 | s54s55s89s97
1043 | s54s55s89s90
1044 | s54s55s86
1045 | s54s55s84s85
1046 | s54s55s78s122
1047 | s54s55s78s98
1048 | s54s55s78s97
1049 | s54s55s76s77s122
1050 | s54s55s76s77s98
1051 | s54s55s76s77s97
1052 | s54s55s68
1053 | s54s55s67
1054 | s54s55s66
1055 | s54s55s65s66
1056 | s54s55s64
1057 | s54s55s64s65
1058 | s54s55s63
1059 | s54s55s63s113
1060 | s54s55s63s91
1061 | s54s55s63s90
1062 | s54s55s63s89
1063 | s54s55s63s78
1064 | s54s55s63s76s77
1065 | s54s55s63s64
1066 | s54s55s59
1067 | s53
1068 | s53s122
1069 | s53s121
1070 | s53s119
1071 | s53s114
1072 | s53s113
1073 | s53s113s114
1074 | s53s111
1075 | s53s105
1076 | s53s103
1077 | s53s98
1078 | s53s97
1079 | s53s96
1080 | s53s93
1081 | s53s92
1082 | s53s91s115
1083 | s53s91s114
1084 | s53s91s113
1085 | s53s91s113s114
1086 | s53s90s122
1087 | s53s90s115
1088 | s53s90s114
1089 | s53s90s113
1090 | s53s90s113s114
1091 | s53s90s103
1092 | s53s90s98
1093 | s53s90s97
1094 | s53s90s93
1095 | s53s89s115
1096 | s53s89s114
1097 | s53s89s113
1098 | s53s89s113s114
1099 | s53s88
1100 | s53s88s91
1101 | s53s88s90
1102 | s53s88s89s113
1103 | s53s88s89s91
1104 | s53s88s89s90
1105 | s53s82
1106 | s53s81
1107 | s53s80
1108 | s53s80s90
1109 | s53s80s81
1110 | s53s79s90
1111 | s53s79s80
1112 | s53s78
1113 | s53s78s115
1114 | s53s78s114
1115 | s53s78s113
1116 | s53s78s113s114
1117 | s53s78s90
1118 | s53s78s88
1119 | s53s77
1120 | s53s77s78
1121 | s53s76s77
1122 | s53s76s77s115
1123 | s53s76s77s114
1124 | s53s76s77s113
1125 | s53s76s77s113s114
1126 | s53s76s77s90
1127 | s53s76s77s88
1128 | s53s76s77s79
1129 | s53s76s77s79s90
1130 | s53s76s77s78
1131 | s53s76s77s78s90
1132 | s53s75s76
1133 | s53s73
1134 | s53s73s122
1135 | s53s73s103
1136 | s53s73s98
1137 | s53s73s97
1138 | s53s73s93
1139 | s53s73s91
1140 | s53s73s90
1141 | s53s73s89
1142 | s53s73s80
1143 | s53s73s79s91
1144 | s53s73s79s90
1145 | s53s73s79s89
1146 | s53s73s78
1147 | s53s73s77s78
1148 | s53s73s77s78s91
1149 | s53s73s77s78s90
1150 | s53s73s77s78s89
1151 | s53s73s76s77
1152 | s53s73s76s77s79
1153 | s53s73s76s77s78
1154 | s53s71s72
1155 | s53s71s72s122
1156 | s53s71s72s103
1157 | s53s71s72s98
1158 | s53s71s72s97
1159 | s53s71s72s93
1160 | s53s71s72s91
1161 | s53s71s72s90
1162 | s53s71s72s89
1163 | s53s71s72s80
1164 | s53s71s72s79s91
1165 | s53s71s72s79s90
1166 | s53s71s72s79s89
1167 | s53s71s72s78
1168 | s53s71s72s77s78
1169 | s53s71s72s77s78s91
1170 | s53s71s72s77s78s90
1171 | s53s71s72s77s78s89
1172 | s53s71s72s76s77
1173 | s53s71s72s76s77s79
1174 | s53s71s72s76s77s78
1175 | s53s68
1176 | s53s66
1177 | s53s65
1178 | s53s65s91
1179 | s53s65s89
1180 | s53s65s78
1181 | s53s65s76s77
1182 | s53s65s73
1183 | s53s65s71s72
1184 | s53s64
1185 | s53s64s90
1186 | s53s64s88s89
1187 | s53s64s65
1188 | s53s63s113
1189 | s53s63s91
1190 | s53s63s90
1191 | s53s63s89s90
1192 | s53s63s73
1193 | s53s63s71s72
1194 | s53s63s64
1195 | s53s63s64s91
1196 | s53s63s64s89
1197 | s53s63s64s78
1198 | s53s63s64s76s77
1199 | s53s63s64s73
1200 | s53s63s64s71s72
1201 | s53s62
1202 | s53s60
1203 | s53s56s91
1204 | s53s56s90
1205 | s53s56s89
1206 | s53s56s78
1207 | s53s56s76s77
1208 | s53s55
1209 | s53s55s113
1210 | s53s55s91
1211 | s53s55s91s113
1212 | s53s55s90
1213 | s53s55s90s113
1214 | s53s55s89
1215 | s53s55s89s113
1216 | s53s55s78
1217 | s53s55s78s113
1218 | s53s55s76s77
1219 | s53s55s76s77s113
1220 | s53s54
1221 | s53s54s125
1222 | s53s54s124
1223 | s53s54s122
1224 | s53s54s120
1225 | s53s54s114
1226 | s53s54s101
1227 | s53s54s100
1228 | s53s54s99s100
1229 | s53s54s98
1230 | s53s54s92s98
1231 | s53s54s91
1232 | s53s54s91s114
1233 | s53s54s90
1234 | s53s54s90s114
1235 | s53s54s90s91
1236 | s53s54s90s91s98
1237 | s53s54s89
1238 | s53s54s89s114
1239 | s53s54s88
1240 | s53s54s88s89
1241 | s53s54s81
1242 | s53s54s79
1243 | s53s54s79s80
1244 | s53s54s78
1245 | s53s54s78s114
1246 | s53s54s76s77
1247 | s53s54s76s77s114
1248 | s53s54s74
1249 | s53s54s73
1250 | s53s54s73s79
1251 | s53s54s73s77s78
1252 | s53s54s71s72
1253 | s53s54s71s72s79
1254 | s53s54s71s72s77s78
1255 | s53s54s67
1256 | s53s54s67s98
1257 | s53s54s66
1258 | s53s54s66s98
1259 | s53s54s65s98
1260 | s53s54s65s66
1261 | s53s54s65s66s98
1262 | s53s54s64s65s98
1263 | s53s54s61
1264 | s53s54s56
1265 | s53s54s55s91
1266 | s53s54s55s90
1267 | s53s54s55s89
1268 | s53s54s55s78
1269 | s53s54s55s76s77
1270 | s52
1271 | s52s112
1272 | s52s110
1273 | s52s98
1274 | s52s97
1275 | s52s90s122
1276 | s52s90s98
1277 | s52s90s97
1278 | s52s85
1279 | s52s83s84
1280 | s52s78s122
1281 | s52s78s98
1282 | s52s78s97
1283 | s52s78s90s122
1284 | s52s78s90s98
1285 | s52s78s90s97
1286 | s52s76s77s122
1287 | s52s76s77s98
1288 | s52s76s77s97
1289 | s52s76s77s90s122
1290 | s52s76s77s90s98
1291 | s52s76s77s90s97
1292 | s52s73s91s122
1293 | s52s73s91s98
1294 | s52s73s91s97
1295 | s52s73s90s122
1296 | s52s73s90s98
1297 | s52s73s90s97
1298 | s52s73s89s122
1299 | s52s73s89s98
1300 | s52s73s89s97
1301 | s52s73s78s122
1302 | s52s73s78s98
1303 | s52s73s78s97
1304 | s52s73s76s77s122
1305 | s52s73s76s77s98
1306 | s52s73s76s77s97
1307 | s52s71s72s91s122
1308 | s52s71s72s91s98
1309 | s52s71s72s91s97
1310 | s52s71s72s90s122
1311 | s52s71s72s90s98
1312 | s52s71s72s90s97
1313 | s52s71s72s89s122
1314 | s52s71s72s89s98
1315 | s52s71s72s89s97
1316 | s52s71s72s78s122
1317 | s52s71s72s78s98
1318 | s52s71s72s78s97
1319 | s52s71s72s76s77s122
1320 | s52s71s72s76s77s98
1321 | s52s71s72s76s77s97
1322 | s52s63s90
1323 | s52s63s78
1324 | s52s63s78s90
1325 | s52s63s76s77
1326 | s52s63s76s77s90
1327 | s52s63s73s91
1328 | s52s63s73s90
1329 | s52s63s73s89
1330 | s52s63s73s78
1331 | s52s63s73s76s77
1332 | s52s63s71s72s91
1333 | s52s63s71s72s90
1334 | s52s63s71s72s89
1335 | s52s63s71s72s78
1336 | s52s63s71s72s76s77
1337 | s52s58
1338 | s52s54s73s122
1339 | s52s54s73s98
1340 | s52s54s73s97
1341 | s52s54s71s72s122
1342 | s52s54s71s72s98
1343 | s52s54s71s72s97
1344 | s52s54s63s73
1345 | s52s54s63s71s72
1346 | s52s53
1347 | s52s53s115
1348 | s52s53s115s122
1349 | s52s53s114
1350 | s52s53s114s122
1351 | s52s53s113
1352 | s52s53s113s122
1353 | s52s53s113s114
1354 | s52s53s113s114s122
1355 | s52s53s98
1356 | s52s53s98s115
1357 | s52s53s98s114
1358 | s52s53s98s113
1359 | s52s53s98s113s114
1360 | s52s53s97s115
1361 | s52s53s97s114
1362 | s52s53s97s113
1363 | s52s53s97s113s114
1364 | s52s53s92
1365 | s52s53s91
1366 | s52s53s90
1367 | s52s53s90s91
1368 | s52s53s89
1369 | s52s53s89s122
1370 | s52s53s89s98
1371 | s52s53s89s97
1372 | s52s53s89s90
1373 | s52s53s88
1374 | s52s53s88s122
1375 | s52s53s88s98
1376 | s52s53s88s97
1377 | s52s53s82
1378 | s52s53s80
1379 | s52s53s80s98
1380 | s52s53s80s81
1381 | s52s53s78
1382 | s52s53s78s90
1383 | s52s53s76s77
1384 | s52s53s76s77s90
1385 | s52s53s73s91
1386 | s52s53s73s90
1387 | s52s53s73s89
1388 | s52s53s73s79
1389 | s52s53s73s79s122
1390 | s52s53s73s79s98
1391 | s52s53s73s79s97
1392 | s52s53s73s78
1393 | s52s53s73s77s78
1394 | s52s53s73s77s78s122
1395 | s52s53s73s77s78s98
1396 | s52s53s73s77s78s97
1397 | s52s53s73s76s77
1398 | s52s53s71s72s91
1399 | s52s53s71s72s90
1400 | s52s53s71s72s89
1401 | s52s53s71s72s79
1402 | s52s53s71s72s79s122
1403 | s52s53s71s72s79s98
1404 | s52s53s71s72s79s97
1405 | s52s53s71s72s78
1406 | s52s53s71s72s77s78
1407 | s52s53s71s72s77s78s122
1408 | s52s53s71s72s77s78s98
1409 | s52s53s71s72s77s78s97
1410 | s52s53s71s72s76s77
1411 | s52s53s69
1412 | s52s53s67
1413 | s52s53s66
1414 | s52s53s65s122
1415 | s52s53s65s98
1416 | s52s53s65s97
1417 | s52s53s65s66
1418 | s52s53s64
1419 | s52s53s64s65
1420 | s52s53s63s115
1421 | s52s53s63s114
1422 | s52s53s63s113
1423 | s52s53s63s113s114
1424 | s52s53s63s89
1425 | s52s53s63s88
1426 | s52s53s63s73s79
1427 | s52s53s63s73s77s78
1428 | s52s53s63s71s72s79
1429 | s52s53s63s71s72s77s78
1430 | s52s53s63s65
1431 | s52s53s63s64s122
1432 | s52s53s63s64s98
1433 | s52s53s63s64s97
1434 | s52s53s56
1435 | s52s53s56s122
1436 | s52s53s56s98
1437 | s52s53s56s97
1438 | s52s53s56s63
1439 | s52s53s55s122
1440 | s52s53s55s113
1441 | s52s53s55s113s122
1442 | s52s53s55s98
1443 | s52s53s55s98s113
1444 | s52s53s55s97
1445 | s52s53s55s97s113
1446 | s52s53s55s73
1447 | s52s53s55s71s72
1448 | s52s53s55s63
1449 | s52s53s55s63s113
1450 | s52s53s54
1451 | s52s53s54s122
1452 | s52s53s54s114
1453 | s52s53s54s114s122
1454 | s52s53s54s98
1455 | s52s53s54s98s114
1456 | s52s53s54s97
1457 | s52s53s54s97s114
1458 | s52s53s54s63
1459 | s52s53s54s63s114
1460 | s52s53s54s55
1461 | s52s53s54s55s122
1462 | s52s53s54s55s98
1463 | s52s53s54s55s97
1464 | s52s53s54s55s63
1465 | s51
1466 | s51s122
1467 | s51s115s122
1468 | s51s114s122
1469 | s51s113s122
1470 | s51s113s114s122
1471 | s51s111
1472 | s51s98
1473 | s51s98s115
1474 | s51s98s114
1475 | s51s98s113
1476 | s51s98s113s114
1477 | s51s97
1478 | s51s97s115
1479 | s51s97s114
1480 | s51s97s113
1481 | s51s97s113s114
1482 | s51s90s122
1483 | s51s90s98
1484 | s51s90s97
1485 | s51s88s122
1486 | s51s88s98
1487 | s51s88s97
1488 | s51s79s122
1489 | s51s79s98
1490 | s51s79s97
1491 | s51s79s90s122
1492 | s51s79s90s98
1493 | s51s79s90s97
1494 | s51s77
1495 | s51s77s78s122
1496 | s51s77s78s98
1497 | s51s77s78s97
1498 | s51s77s78s90s122
1499 | s51s77s78s90s98
1500 | s51s77s78s90s97
1501 | s51s76
1502 | s51s73s122
1503 | s51s73s98
1504 | s51s73s97
1505 | s51s73s79s122
1506 | s51s73s79s98
1507 | s51s73s79s97
1508 | s51s73s77s78s122
1509 | s51s73s77s78s98
1510 | s51s73s77s78s97
1511 | s51s71s72s122
1512 | s51s71s72s98
1513 | s51s71s72s97
1514 | s51s71s72s79s122
1515 | s51s71s72s79s98
1516 | s51s71s72s79s97
1517 | s51s71s72s77s78s122
1518 | s51s71s72s77s78s98
1519 | s51s71s72s77s78s97
1520 | s51s68
1521 | s51s65s122
1522 | s51s65s98
1523 | s51s65s97
1524 | s51s63
1525 | s51s63s115
1526 | s51s63s114
1527 | s51s63s113
1528 | s51s63s113s114
1529 | s51s63s90
1530 | s51s63s88
1531 | s51s63s79
1532 | s51s63s79s90
1533 | s51s63s77s78
1534 | s51s63s77s78s90
1535 | s51s63s73
1536 | s51s63s73s79
1537 | s51s63s73s77s78
1538 | s51s63s71s72
1539 | s51s63s71s72s79
1540 | s51s63s71s72s77s78
1541 | s51s63s65
1542 | s51s63s64
1543 | s51s63s64s122
1544 | s51s63s64s98
1545 | s51s63s64s97
1546 | s51s56s122
1547 | s51s56s98
1548 | s51s56s97
1549 | s51s56s63
1550 | s51s55s122
1551 | s51s55s113s122
1552 | s51s55s98
1553 | s51s55s98s113
1554 | s51s55s97
1555 | s51s55s97s113
1556 | s51s55s63
1557 | s51s55s63s113
1558 | s51s54s122
1559 | s51s54s114s122
1560 | s51s54s98
1561 | s51s54s98s114
1562 | s51s54s97
1563 | s51s54s97s114
1564 | s51s54s63
1565 | s51s54s63s114
1566 | s51s54s55s122
1567 | s51s54s55s98
1568 | s51s54s55s97
1569 | s51s54s55s63
1570 | s51s53
1571 | s51s53s115
1572 | s51s53s114
1573 | s51s53s113
1574 | s51s53s113s114
1575 | s51s53s90
1576 | s51s53s88
1577 | s51s53s79
1578 | s51s53s79s90
1579 | s51s53s77s78
1580 | s51s53s77s78s90
1581 | s51s53s73
1582 | s51s53s73s79
1583 | s51s53s73s77s78
1584 | s51s53s71s72
1585 | s51s53s71s72s79
1586 | s51s53s71s72s77s78
1587 | s51s53s65
1588 | s51s53s63s64
1589 | s51s53s56
1590 | s51s53s55
1591 | s51s53s55s113
1592 | s51s53s54
1593 | s51s53s54s114
1594 | s51s53s54s55
1595 | s51s52
1596 | s51s52s122
1597 | s51s52s98
1598 | s51s52s97
1599 | s51s52s90s122
1600 | s51s52s90s98
1601 | s51s52s90s97
1602 | s51s52s73s122
1603 | s51s52s73s98
1604 | s51s52s73s97
1605 | s51s52s71s72s122
1606 | s51s52s71s72s98
1607 | s51s52s71s72s97
1608 | s51s52s63
1609 | s51s52s63s90
1610 | s51s52s63s73
1611 | s51s52s63s71s72
1612 | s51s52s53
1613 | s51s52s53s90
1614 | s51s52s53s73
1615 | s51s52s53s71s72
1616 | s50s122
1617 | s50s98
1618 | s50s97
1619 | s50s73
1620 | s50s71s72
1621 | s50s63
1622 | s50s53
1623 | s49s50s55
1624 | s49s50s53s54
1625 | s48s49
1626 | s48s49s73
1627 | s48s49s71s72
1628 | s47
1629 | s47s89
1630 | s46
1631 | s46s122
1632 | s46s103s122
1633 | s46s100
1634 | s46s99
1635 | s46s98s103
1636 | s46s97s103
1637 | s46s94
1638 | s46s93
1639 | s46s93s122
1640 | s46s93s98
1641 | s46s93s97
1642 | s46s92
1643 | s46s91s122
1644 | s46s91s98
1645 | s46s91s97
1646 | s46s90
1647 | s46s90s122
1648 | s46s90s98
1649 | s46s90s97
1650 | s46s90s91
1651 | s46s89
1652 | s46s89s122
1653 | s46s89s98
1654 | s46s89s97
1655 | s46s88
1656 | s46s86
1657 | s46s84s85
1658 | s46s80s122
1659 | s46s80s98
1660 | s46s80s97
1661 | s46s79s91s122
1662 | s46s79s91s98
1663 | s46s79s91s97
1664 | s46s79s90s122
1665 | s46s79s90s98
1666 | s46s79s90s97
1667 | s46s79s89s122
1668 | s46s79s89s98
1669 | s46s79s89s97
1670 | s46s78s122
1671 | s46s78s98
1672 | s46s78s97
1673 | s46s77s78s122
1674 | s46s77s78s98
1675 | s46s77s78s97
1676 | s46s77s78s91s122
1677 | s46s77s78s91s98
1678 | s46s77s78s91s97
1679 | s46s77s78s90s122
1680 | s46s77s78s90s98
1681 | s46s77s78s90s97
1682 | s46s77s78s89s122
1683 | s46s77s78s89s98
1684 | s46s77s78s89s97
1685 | s46s76s77s122
1686 | s46s76s77s98
1687 | s46s76s77s97
1688 | s46s76s77s79s122
1689 | s46s76s77s79s98
1690 | s46s76s77s79s97
1691 | s46s76s77s78s122
1692 | s46s76s77s78s98
1693 | s46s76s77s78s97
1694 | s46s73
1695 | s46s70
1696 | s46s69
1697 | s46s66
1698 | s46s65
1699 | s46s65s122
1700 | s46s65s98
1701 | s46s65s97
1702 | s46s64s65
1703 | s46s63
1704 | s46s63s103
1705 | s46s63s93
1706 | s46s63s91
1707 | s46s63s90
1708 | s46s63s89
1709 | s46s63s80
1710 | s46s63s79s91
1711 | s46s63s79s90
1712 | s46s63s79s89
1713 | s46s63s78
1714 | s46s63s77s78
1715 | s46s63s77s78s91
1716 | s46s63s77s78s90
1717 | s46s63s77s78s89
1718 | s46s63s76s77
1719 | s46s63s76s77s79
1720 | s46s63s76s77s78
1721 | s46s63s65
1722 | s46s63s64
1723 | s46s63s64s122
1724 | s46s63s64s98
1725 | s46s63s64s97
1726 | s46s61
1727 | s46s59
1728 | s46s56
1729 | s46s54
1730 | s46s54s122
1731 | s46s54s98
1732 | s46s54s97
1733 | s46s54s79s122
1734 | s46s54s79s98
1735 | s46s54s79s97
1736 | s46s54s77s78s122
1737 | s46s54s77s78s98
1738 | s46s54s77s78s97
1739 | s46s54s63
1740 | s46s54s63s79
1741 | s46s54s63s77s78
1742 | s46s53s122
1743 | s46s53s103
1744 | s46s53s98
1745 | s46s53s97
1746 | s46s53s93
1747 | s46s53s91
1748 | s46s53s90
1749 | s46s53s89
1750 | s46s53s80
1751 | s46s53s79s91
1752 | s46s53s79s90
1753 | s46s53s79s89
1754 | s46s53s78
1755 | s46s53s77s78
1756 | s46s53s77s78s91
1757 | s46s53s77s78s90
1758 | s46s53s77s78s89
1759 | s46s53s76s77
1760 | s46s53s76s77s79
1761 | s46s53s76s77s78
1762 | s46s53s65
1763 | s46s53s63
1764 | s46s53s63s64
1765 | s46s53s54
1766 | s46s53s54s79
1767 | s46s53s54s77s78
1768 | s46s52s91s122
1769 | s46s52s91s98
1770 | s46s52s91s97
1771 | s46s52s90s122
1772 | s46s52s90s98
1773 | s46s52s90s97
1774 | s46s52s89s122
1775 | s46s52s89s98
1776 | s46s52s89s97
1777 | s46s52s78s122
1778 | s46s52s78s98
1779 | s46s52s78s97
1780 | s46s52s76s77s122
1781 | s46s52s76s77s98
1782 | s46s52s76s77s97
1783 | s46s52s63s91
1784 | s46s52s63s90
1785 | s46s52s63s89
1786 | s46s52s63s78
1787 | s46s52s63s76s77
1788 | s46s52s54s122
1789 | s46s52s54s98
1790 | s46s52s54s97
1791 | s46s52s54s63
1792 | s46s52s53s91
1793 | s46s52s53s90
1794 | s46s52s53s89
1795 | s46s52s53s79
1796 | s46s52s53s79s122
1797 | s46s52s53s79s98
1798 | s46s52s53s79s97
1799 | s46s52s53s78
1800 | s46s52s53s77s78
1801 | s46s52s53s77s78s122
1802 | s46s52s53s77s78s98
1803 | s46s52s53s77s78s97
1804 | s46s52s53s76s77
1805 | s46s52s53s63s79
1806 | s46s52s53s63s77s78
1807 | s46s52s53s55
1808 | s46s51s122
1809 | s46s51s98
1810 | s46s51s97
1811 | s46s51s79s122
1812 | s46s51s79s98
1813 | s46s51s79s97
1814 | s46s51s77s78s122
1815 | s46s51s77s78s98
1816 | s46s51s77s78s97
1817 | s46s51s63
1818 | s46s51s63s79
1819 | s46s51s63s77s78
1820 | s46s51s53
1821 | s46s51s53s79
1822 | s46s51s53s77s78
1823 | s46s51s52s122
1824 | s46s51s52s98
1825 | s46s51s52s97
1826 | s46s51s52s63
1827 | s46s51s52s53
1828 | s46s50
1829 | s46s48s49
1830 | s45s98
1831 | s45s83
1832 | s45s82
1833 | s45s81s82
1834 | s45s80s81
1835 | s45s56
1836 | s45s55
1837 | s45s46
1838 | s45s46s89
1839 | s44
1840 | s44s122
1841 | s44s98
1842 | s44s97
1843 | s44s91
1844 | s44s90s122
1845 | s44s90s98
1846 | s44s90s97
1847 | s44s89s90
1848 | s44s73s122
1849 | s44s73s98
1850 | s44s73s97
1851 | s44s71s72s122
1852 | s44s71s72s98
1853 | s44s71s72s97
1854 | s44s64
1855 | s44s63
1856 | s44s63s90
1857 | s44s63s73
1858 | s44s63s71s72
1859 | s44s53
1860 | s44s53s90
1861 | s44s53s73
1862 | s44s53s71s72
1863 | s44s46s122
1864 | s44s46s98
1865 | s44s46s97
1866 | s44s46s63
1867 | s44s46s53
1868 | s43
1869 | s43s82
1870 | s42
1871 | s42s90
1872 | s42s88s89
1873 | s42s63
1874 | s42s55
1875 | s42s53s54
1876 | s41
1877 | s41s55
1878 | s41s55s99
1879 | s41s53s54
1880 | s41s53s54s99
1881 | s40
1882 | s40s115
1883 | s40s114
1884 | s40s113
1885 | s40s113s114
1886 | s40s98
1887 | s40s96
1888 | s40s88
1889 | s40s86
1890 | s40s84s85
1891 | s40s73
1892 | s40s71s72
1893 | s40s70s98
1894 | s40s68
1895 | s40s68s98
1896 | s40s65
1897 | s40s63s64
1898 | s40s59
1899 | s40s56
1900 | s40s55s113
1901 | s40s55s100
1902 | s40s55s98
1903 | s40s54s114
1904 | s40s54s55
1905 | s40s53s54
1906 | s40s53s54s100
1907 | s40s53s54s98
1908 | s40s52s53
1909 | s40s46
1910 | s40s41
1911 | s40s41s90
1912 | s40s41s88s89
1913 | s40s41s63
1914 | s40s41s55
1915 | s40s41s53s54
1916 | s39s121
1917 | s39s119
1918 | s39s114
1919 | s39s113
1920 | s39s113s114
1921 | s39s105
1922 | s39s104
1923 | s39s103
1924 | s39s98
1925 | s39s97
1926 | s39s93
1927 | s39s91s115
1928 | s39s91s114
1929 | s39s91s113
1930 | s39s91s113s114
1931 | s39s90
1932 | s39s90s115
1933 | s39s90s114
1934 | s39s90s113
1935 | s39s90s113s114
1936 | s39s90s103
1937 | s39s90s93
1938 | s39s90s91
1939 | s39s89
1940 | s39s89s115
1941 | s39s89s114
1942 | s39s89s113
1943 | s39s89s113s114
1944 | s39s88s91
1945 | s39s88s90
1946 | s39s88s89s91
1947 | s39s88s89s90
1948 | s39s81
1949 | s39s80
1950 | s39s80s90
1951 | s39s80s81
1952 | s39s79
1953 | s39s79s90
1954 | s39s79s80
1955 | s39s78
1956 | s39s78s115
1957 | s39s78s114
1958 | s39s78s113
1959 | s39s78s113s114
1960 | s39s78s90
1961 | s39s78s88
1962 | s39s78s79
1963 | s39s77
1964 | s39s76s77
1965 | s39s76s77s115
1966 | s39s76s77s114
1967 | s39s76s77s113
1968 | s39s76s77s113s114
1969 | s39s76s77s90
1970 | s39s76s77s88
1971 | s39s76s77s79
1972 | s39s76s77s79s90
1973 | s39s76s77s78
1974 | s39s76s77s78s90
1975 | s39s75s76
1976 | s39s73
1977 | s39s73s103
1978 | s39s73s93
1979 | s39s73s91
1980 | s39s73s90
1981 | s39s73s89
1982 | s39s73s80
1983 | s39s73s79s91
1984 | s39s73s79s90
1985 | s39s73s79s89
1986 | s39s73s78
1987 | s39s73s77s78
1988 | s39s73s77s78s91
1989 | s39s73s77s78s90
1990 | s39s73s77s78s89
1991 | s39s73s76s77
1992 | s39s73s76s77s79
1993 | s39s73s76s77s78
1994 | s39s71s72s103
1995 | s39s71s72s93
1996 | s39s71s72s91
1997 | s39s71s72s90
1998 | s39s71s72s89
1999 | s39s71s72s80
2000 | s39s71s72s79s91
2001 | s39s71s72s79s90
2002 | s39s71s72s79s89
2003 | s39s71s72s78
2004 | s39s71s72s77s78
2005 | s39s71s72s77s78s91
2006 | s39s71s72s77s78s90
2007 | s39s71s72s77s78s89
2008 | s39s71s72s76s77
2009 | s39s71s72s76s77s79
2010 | s39s71s72s76s77s78
2011 | s39s70s98
2012 | s39s70s92
2013 | s39s70s90
2014 | s39s70s90s91
2015 | s39s70s88s89
2016 | s39s68
2017 | s39s68s98
2018 | s39s68s92
2019 | s39s68s90s91
2020 | s39s67s98
2021 | s39s67s70
2022 | s39s67s68
2023 | s39s66
2024 | s39s66s70
2025 | s39s66s68
2026 | s39s66s67
2027 | s39s65s91
2028 | s39s65s89
2029 | s39s65s78
2030 | s39s65s76s77
2031 | s39s65s73
2032 | s39s65s71s72
2033 | s39s65s70
2034 | s39s65s68
2035 | s39s65s66
2036 | s39s65s66s70
2037 | s39s65s66s68
2038 | s39s64
2039 | s39s64s90
2040 | s39s64s88s89
2041 | s39s64s65
2042 | s39s64s65s70
2043 | s39s64s65s68
2044 | s39s64s65s67
2045 | s39s63
2046 | s39s63s91
2047 | s39s63s89s90
2048 | s39s63s70
2049 | s39s63s64
2050 | s39s63s64s91
2051 | s39s63s64s89
2052 | s39s63s64s78
2053 | s39s63s64s76s77
2054 | s39s63s64s73
2055 | s39s63s64s71s72
2056 | s39s62
2057 | s39s60
2058 | s39s56s91
2059 | s39s56s90
2060 | s39s56s89
2061 | s39s56s78
2062 | s39s56s76s77
2063 | s39s55s113
2064 | s39s55s98
2065 | s39s55s92
2066 | s39s55s91
2067 | s39s55s91s113
2068 | s39s55s90
2069 | s39s55s90s113
2070 | s39s55s90s91
2071 | s39s55s89
2072 | s39s55s89s113
2073 | s39s55s78
2074 | s39s55s78s113
2075 | s39s55s76s77
2076 | s39s55s76s77s113
2077 | s39s55s67
2078 | s39s55s66
2079 | s39s55s65
2080 | s39s55s65s66
2081 | s39s55s64s65
2082 | s39s54
2083 | s39s54s115
2084 | s39s54s114
2085 | s39s54s113
2086 | s39s54s113s114
2087 | s39s54s91
2088 | s39s54s91s114
2089 | s39s54s90
2090 | s39s54s90s114
2091 | s39s54s89s114
2092 | s39s54s88
2093 | s39s54s80
2094 | s39s54s78
2095 | s39s54s78s114
2096 | s39s54s76s77
2097 | s39s54s76s77s114
2098 | s39s54s73
2099 | s39s54s73s79
2100 | s39s54s73s77s78
2101 | s39s54s71s72
2102 | s39s54s71s72s79
2103 | s39s54s71s72s77s78
2104 | s39s54s65
2105 | s39s54s63s64
2106 | s39s54s56
2107 | s39s54s55
2108 | s39s54s55s113
2109 | s39s54s55s91
2110 | s39s54s55s90
2111 | s39s54s55s89
2112 | s39s54s55s78
2113 | s39s54s55s76s77
2114 | s39s53s90
2115 | s39s53s73
2116 | s39s53s71s72
2117 | s39s53s54s98
2118 | s39s53s54s92
2119 | s39s53s54s90s91
2120 | s39s53s54s67
2121 | s39s53s54s66
2122 | s39s53s54s65
2123 | s39s53s54s65s66
2124 | s39s53s54s64s65
2125 | s39s52
2126 | s39s52s90
2127 | s39s52s78
2128 | s39s52s78s90
2129 | s39s52s76s77
2130 | s39s52s76s77s90
2131 | s39s52s73s91
2132 | s39s52s73s90
2133 | s39s52s73s89
2134 | s39s52s73s78
2135 | s39s52s73s76s77
2136 | s39s52s71s72s91
2137 | s39s52s71s72s90
2138 | s39s52s71s72s89
2139 | s39s52s71s72s78
2140 | s39s52s71s72s76s77
2141 | s39s52s54s73
2142 | s39s52s54s71s72
2143 | s39s52s53s115
2144 | s39s52s53s114
2145 | s39s52s53s113
2146 | s39s52s53s113s114
2147 | s39s52s53s89
2148 | s39s52s53s88
2149 | s39s52s53s80
2150 | s39s52s53s73s79
2151 | s39s52s53s73s77s78
2152 | s39s52s53s71s72s79
2153 | s39s52s53s71s72s77s78
2154 | s39s52s53s65
2155 | s39s52s53s63s64
2156 | s39s52s53s56
2157 | s39s52s53s55
2158 | s39s52s53s55s113
2159 | s39s52s53s54
2160 | s39s52s53s54s114
2161 | s39s52s53s54s55
2162 | s39s51
2163 | s39s51s115
2164 | s39s51s114
2165 | s39s51s113
2166 | s39s51s113s114
2167 | s39s51s90
2168 | s39s51s88
2169 | s39s51s79
2170 | s39s51s79s90
2171 | s39s51s77s78
2172 | s39s51s77s78s90
2173 | s39s51s73
2174 | s39s51s73s79
2175 | s39s51s73s77s78
2176 | s39s51s71s72
2177 | s39s51s71s72s79
2178 | s39s51s71s72s77s78
2179 | s39s51s65
2180 | s39s51s63s64
2181 | s39s51s56
2182 | s39s51s55
2183 | s39s51s55s113
2184 | s39s51s54
2185 | s39s51s54s114
2186 | s39s51s54s55
2187 | s39s51s52
2188 | s39s51s52s90
2189 | s39s51s52s73
2190 | s39s51s52s71s72
2191 | s39s50
2192 | s39s46
2193 | s39s46s103
2194 | s39s46s93
2195 | s39s46s91
2196 | s39s46s90
2197 | s39s46s89
2198 | s39s46s80
2199 | s39s46s79s91
2200 | s39s46s79s90
2201 | s39s46s79s89
2202 | s39s46s78
2203 | s39s46s77s78
2204 | s39s46s77s78s91
2205 | s39s46s77s78s90
2206 | s39s46s77s78s89
2207 | s39s46s76s77
2208 | s39s46s76s77s79
2209 | s39s46s76s77s78
2210 | s39s46s65
2211 | s39s46s63s64
2212 | s39s46s54
2213 | s39s46s54s79
2214 | s39s46s54s77s78
2215 | s39s46s53
2216 | s39s46s52s91
2217 | s39s46s52s90
2218 | s39s46s52s89
2219 | s39s46s52s78
2220 | s39s46s52s76s77
2221 | s39s46s52s54
2222 | s39s46s52s53s79
2223 | s39s46s52s53s77s78
2224 | s39s46s51
2225 | s39s46s51s79
2226 | s39s46s51s77s78
2227 | s39s46s51s52
2228 | s39s45
2229 | s39s44
2230 | s39s44s90
2231 | s39s44s73
2232 | s39s44s71s72
2233 | s39s44s46
2234 | s39s40s73
2235 | s39s40s71s72
2236 | s39s40s70
2237 | s39s40s68
2238 | s39s40s55
2239 | s39s40s53s54
2240 | s39s40s46
2241 | s38
2242 | s38s124
2243 | s38s123
2244 | s38s119
2245 | s38s115
2246 | s38s105
2247 | s38s103
2248 | s38s98
2249 | s38s93
2250 | s38s92
2251 | s38s91
2252 | s38s91s122
2253 | s38s91s115
2254 | s38s91s114
2255 | s38s91s113
2256 | s38s91s113s114
2257 | s38s91s98
2258 | s38s91s97
2259 | s38s90
2260 | s38s90s115
2261 | s38s90s114
2262 | s38s90s113
2263 | s38s90s113s114
2264 | s38s90s103
2265 | s38s90s93
2266 | s38s89s122
2267 | s38s89s115
2268 | s38s89s114
2269 | s38s89s113
2270 | s38s89s113s114
2271 | s38s89s98
2272 | s38s89s97
2273 | s38s88
2274 | s38s88s91
2275 | s38s88s90
2276 | s38s88s89
2277 | s38s88s89s91
2278 | s38s88s89s90
2279 | s38s86
2280 | s38s84s85
2281 | s38s82
2282 | s38s81
2283 | s38s80
2284 | s38s80s90
2285 | s38s80s81
2286 | s38s79s90
2287 | s38s79s80
2288 | s38s78
2289 | s38s78s122
2290 | s38s78s115
2291 | s38s78s114
2292 | s38s78s113
2293 | s38s78s113s114
2294 | s38s78s98
2295 | s38s78s97
2296 | s38s78s90
2297 | s38s78s88
2298 | s38s77
2299 | s38s77s78
2300 | s38s76s77s122
2301 | s38s76s77s115
2302 | s38s76s77s114
2303 | s38s76s77s113
2304 | s38s76s77s113s114
2305 | s38s76s77s98
2306 | s38s76s77s97
2307 | s38s76s77s90
2308 | s38s76s77s88
2309 | s38s76s77s79
2310 | s38s76s77s79s90
2311 | s38s76s77s78
2312 | s38s76s77s78s90
2313 | s38s75s76
2314 | s38s73s122
2315 | s38s73s103
2316 | s38s73s98
2317 | s38s73s97
2318 | s38s73s93
2319 | s38s73s91
2320 | s38s73s90
2321 | s38s73s89
2322 | s38s73s80
2323 | s38s73s79s91
2324 | s38s73s79s90
2325 | s38s73s79s89
2326 | s38s73s78
2327 | s38s73s77s78
2328 | s38s73s77s78s91
2329 | s38s73s77s78s90
2330 | s38s73s77s78s89
2331 | s38s73s76s77
2332 | s38s73s76s77s79
2333 | s38s73s76s77s78
2334 | s38s71s72s122
2335 | s38s71s72s103
2336 | s38s71s72s98
2337 | s38s71s72s97
2338 | s38s71s72s93
2339 | s38s71s72s91
2340 | s38s71s72s90
2341 | s38s71s72s89
2342 | s38s71s72s80
2343 | s38s71s72s79s91
2344 | s38s71s72s79s90
2345 | s38s71s72s79s89
2346 | s38s71s72s78
2347 | s38s71s72s77s78
2348 | s38s71s72s77s78s91
2349 | s38s71s72s77s78s90
2350 | s38s71s72s77s78s89
2351 | s38s71s72s76s77
2352 | s38s71s72s76s77s79
2353 | s38s71s72s76s77s78
2354 | s38s70
2355 | s38s68
2356 | s38s67
2357 | s38s65s91
2358 | s38s65s89
2359 | s38s65s78
2360 | s38s65s76s77
2361 | s38s65s73
2362 | s38s65s71s72
2363 | s38s65s66
2364 | s38s64s90
2365 | s38s64s88s89
2366 | s38s63s89
2367 | s38s63s89s90
2368 | s38s63s78
2369 | s38s63s76s77
2370 | s38s63s73
2371 | s38s63s71s72
2372 | s38s63s64
2373 | s38s63s64s91
2374 | s38s63s64s89
2375 | s38s63s64s78
2376 | s38s63s64s76s77
2377 | s38s63s64s73
2378 | s38s63s64s71s72
2379 | s38s60
2380 | s38s59
2381 | s38s56
2382 | s38s56s91
2383 | s38s56s90
2384 | s38s56s89
2385 | s38s56s78
2386 | s38s56s76s77
2387 | s38s55
2388 | s38s55s91
2389 | s38s55s91s113
2390 | s38s55s90
2391 | s38s55s90s113
2392 | s38s55s89
2393 | s38s55s89s113
2394 | s38s55s78
2395 | s38s55s78s113
2396 | s38s55s76s77
2397 | s38s55s76s77s113
2398 | s38s54s122
2399 | s38s54s115
2400 | s38s54s113
2401 | s38s54s113s114
2402 | s38s54s98
2403 | s38s54s97
2404 | s38s54s91
2405 | s38s54s91s114
2406 | s38s54s90
2407 | s38s54s90s114
2408 | s38s54s89s114
2409 | s38s54s88
2410 | s38s54s78
2411 | s38s54s78s114
2412 | s38s54s76s77
2413 | s38s54s76s77s114
2414 | s38s54s73
2415 | s38s54s73s79
2416 | s38s54s73s77s78
2417 | s38s54s71s72
2418 | s38s54s71s72s79
2419 | s38s54s71s72s77s78
2420 | s38s54s65
2421 | s38s54s63
2422 | s38s54s63s64
2423 | s38s54s56
2424 | s38s54s55s113
2425 | s38s54s55s91
2426 | s38s54s55s90
2427 | s38s54s55s89
2428 | s38s54s55s78
2429 | s38s54s55s76s77
2430 | s38s53
2431 | s38s53s91
2432 | s38s53s90
2433 | s38s53s89
2434 | s38s53s78
2435 | s38s53s76s77
2436 | s38s52
2437 | s38s52s90
2438 | s38s52s78
2439 | s38s52s78s90
2440 | s38s52s76s77
2441 | s38s52s76s77s90
2442 | s38s52s73s91
2443 | s38s52s73s90
2444 | s38s52s73s89
2445 | s38s52s73s78
2446 | s38s52s73s76s77
2447 | s38s52s71s72s91
2448 | s38s52s71s72s90
2449 | s38s52s71s72s89
2450 | s38s52s71s72s78
2451 | s38s52s71s72s76s77
2452 | s38s52s54s73
2453 | s38s52s54s71s72
2454 | s38s52s53s122
2455 | s38s52s53s115
2456 | s38s52s53s114
2457 | s38s52s53s113
2458 | s38s52s53s113s114
2459 | s38s52s53s98
2460 | s38s52s53s97
2461 | s38s52s53s89
2462 | s38s52s53s88
2463 | s38s52s53s73s79
2464 | s38s52s53s73s77s78
2465 | s38s52s53s71s72s79
2466 | s38s52s53s71s72s77s78
2467 | s38s52s53s65
2468 | s38s52s53s63
2469 | s38s52s53s63s64
2470 | s38s52s53s56
2471 | s38s52s53s55
2472 | s38s52s53s55s113
2473 | s38s52s53s54
2474 | s38s52s53s54s114
2475 | s38s52s53s54s55
2476 | s38s51s122
2477 | s38s51s115
2478 | s38s51s114
2479 | s38s51s113
2480 | s38s51s113s114
2481 | s38s51s98
2482 | s38s51s97
2483 | s38s51s90
2484 | s38s51s88
2485 | s38s51s79
2486 | s38s51s79s90
2487 | s38s51s77s78
2488 | s38s51s77s78s90
2489 | s38s51s73
2490 | s38s51s73s79
2491 | s38s51s73s77s78
2492 | s38s51s71s72
2493 | s38s51s71s72s79
2494 | s38s51s71s72s77s78
2495 | s38s51s65
2496 | s38s51s63
2497 | s38s51s63s64
2498 | s38s51s56
2499 | s38s51s55
2500 | s38s51s55s113
2501 | s38s51s54
2502 | s38s51s54s114
2503 | s38s51s54s55
2504 | s38s51s53
2505 | s38s51s52
2506 | s38s51s52s90
2507 | s38s51s52s73
2508 | s38s51s52s71s72
2509 | s38s50
2510 | s38s46
2511 | s38s46s122
2512 | s38s46s103
2513 | s38s46s98
2514 | s38s46s97
2515 | s38s46s93
2516 | s38s46s91
2517 | s38s46s90
2518 | s38s46s89
2519 | s38s46s80
2520 | s38s46s79s91
2521 | s38s46s79s90
2522 | s38s46s79s89
2523 | s38s46s78
2524 | s38s46s77s78
2525 | s38s46s77s78s91
2526 | s38s46s77s78s90
2527 | s38s46s77s78s89
2528 | s38s46s76s77
2529 | s38s46s76s77s79
2530 | s38s46s76s77s78
2531 | s38s46s65
2532 | s38s46s63
2533 | s38s46s63s64
2534 | s38s46s54
2535 | s38s46s54s79
2536 | s38s46s54s77s78
2537 | s38s46s52s91
2538 | s38s46s52s90
2539 | s38s46s52s89
2540 | s38s46s52s78
2541 | s38s46s52s76s77
2542 | s38s46s52s54
2543 | s38s46s52s53s79
2544 | s38s46s52s53s77s78
2545 | s38s46s51
2546 | s38s46s51s79
2547 | s38s46s51s77s78
2548 | s38s46s51s52
2549 | s38s44
2550 | s38s44s90
2551 | s38s44s73
2552 | s38s44s71s72
2553 | s38s44s46
2554 | s38s40
2555 | s38s39
2556 | s38s39s91
2557 | s38s39s89
2558 | s38s39s78
2559 | s38s39s76s77
2560 | s38s39s73
2561 | s38s39s71s72
2562 | s38s39s54
2563 | s38s39s52s53
2564 | s38s39s51
2565 | s38s39s46
2566 | s37s124
2567 | s37s121
2568 | s37s112
2569 | s37s102
2570 | s37s95
2571 | s37s94
2572 | s37s91
2573 | s37s89s90
2574 | s37s88s89
2575 | s37s86
2576 | s37s83
2577 | s37s81
2578 | s37s79
2579 | s37s79s80
2580 | s37s78
2581 | s37s77
2582 | s37s70
2583 | s37s68
2584 | s37s68s69
2585 | s37s67
2586 | s37s65
2587 | s37s65s66
2588 | s37s64
2589 | s37s63
2590 | s37s62
2591 | s37s55
2592 | s37s54
2593 | s37s53
2594 | s37s40
2595 | s36s124
2596 | s36s96
2597 | s36s65
2598 | s36s55
2599 | s36s37
2600 | s35s98
2601 | s35s96
2602 | s35s90
2603 | s35s83
2604 | s35s82
2605 | s35s81s82
2606 | s35s80s81
2607 | s35s73
2608 | s35s71s72
2609 | s35s56
2610 | s35s55
2611 | s35s46
2612 | s35s39
2613 | s35s37
2614 | s34
2615 | s34s122
2616 | s34s98
2617 | s34s97
2618 | s34s90
2619 | s34s90s122
2620 | s34s90s98
2621 | s34s90s97
2622 | s34s89
2623 | s34s73
2624 | s34s73s122
2625 | s34s73s98
2626 | s34s73s97
2627 | s34s71s72
2628 | s34s71s72s122
2629 | s34s71s72s98
2630 | s34s71s72s97
2631 | s34s63
2632 | s34s63s90
2633 | s34s63s73
2634 | s34s63s71s72
2635 | s34s53
2636 | s34s53s90
2637 | s34s53s73
2638 | s34s53s71s72
2639 | s34s46
2640 | s34s46s122
2641 | s34s46s98
2642 | s34s46s97
2643 | s34s46s63
2644 | s34s46s53
2645 | s34s39
2646 | s34s39s90
2647 | s34s39s73
2648 | s34s39s71s72
2649 | s34s39s46
2650 | s34s38
2651 | s34s38s90
2652 | s34s38s73
2653 | s34s38s71s72
2654 | s34s38s46
2655 | s33s96
2656 | s33s82
2657 | s33s55
2658 | s33s53s54
2659 | s33s37
2660 | s33s34
2661 | s32s126
2662 | s32s122
2663 | s32s115s122
2664 | s32s114s122
2665 | s32s113s122
2666 | s32s113s114s122
2667 | s32s98s115
2668 | s32s98s114
2669 | s32s98s113
2670 | s32s98s113s114
2671 | s32s97
2672 | s32s97s115
2673 | s32s97s114
2674 | s32s97s113
2675 | s32s97s113s114
2676 | s32s88s122
2677 | s32s88s98
2678 | s32s88s97
2679 | s32s81
2680 | s32s77
2681 | s32s73s122
2682 | s32s73s98
2683 | s32s73s97
2684 | s32s73s79s122
2685 | s32s73s79s98
2686 | s32s73s79s97
2687 | s32s73s77s78s122
2688 | s32s73s77s78s98
2689 | s32s73s77s78s97
2690 | s32s71s72s122
2691 | s32s71s72s98
2692 | s32s71s72s97
2693 | s32s71s72s79s122
2694 | s32s71s72s79s98
2695 | s32s71s72s79s97
2696 | s32s71s72s77s78s122
2697 | s32s71s72s77s78s98
2698 | s32s71s72s77s78s97
2699 | s32s67
2700 | s32s66
2701 | s32s65s122
2702 | s32s65s98
2703 | s32s65s97
2704 | s32s64s65
2705 | s32s63
2706 | s32s63s115
2707 | s32s63s114
2708 | s32s63s113
2709 | s32s63s113s114
2710 | s32s63s88
2711 | s32s63s73
2712 | s32s63s73s79
2713 | s32s63s73s77s78
2714 | s32s63s71s72
2715 | s32s63s71s72s79
2716 | s32s63s71s72s77s78
2717 | s32s63s65
2718 | s32s63s64
2719 | s32s63s64s122
2720 | s32s63s64s98
2721 | s32s63s64s97
2722 | s32s57
2723 | s32s56s122
2724 | s32s56s98
2725 | s32s56s97
2726 | s32s56s63
2727 | s32s55s122
2728 | s32s55s113s122
2729 | s32s55s98
2730 | s32s55s98s113
2731 | s32s55s97
2732 | s32s55s97s113
2733 | s32s55s63
2734 | s32s55s63s113
2735 | s32s54s122
2736 | s32s54s114s122
2737 | s32s54s98
2738 | s32s54s98s114
2739 | s32s54s97
2740 | s32s54s97s114
2741 | s32s54s63
2742 | s32s54s63s114
2743 | s32s54s55s122
2744 | s32s54s55s98
2745 | s32s54s55s97
2746 | s32s54s55s63
2747 | s32s53
2748 | s32s53s115
2749 | s32s53s114
2750 | s32s53s113
2751 | s32s53s113s114
2752 | s32s53s88
2753 | s32s53s73
2754 | s32s53s73s79
2755 | s32s53s73s77s78
2756 | s32s53s71s72
2757 | s32s53s71s72s79
2758 | s32s53s71s72s77s78
2759 | s32s53s65
2760 | s32s53s63s64
2761 | s32s53s56
2762 | s32s53s55
2763 | s32s53s55s113
2764 | s32s53s54
2765 | s32s53s54s114
2766 | s32s53s54s55
2767 | s32s52s73s122
2768 | s32s52s73s98
2769 | s32s52s73s97
2770 | s32s52s71s72s122
2771 | s32s52s71s72s98
2772 | s32s52s71s72s97
2773 | s32s52s63s73
2774 | s32s52s63s71s72
2775 | s32s52s53s73
2776 | s32s52s53s71s72
2777 | s32s46s122
2778 | s32s46s98
2779 | s32s46s97
2780 | s32s46s79s122
2781 | s32s46s79s98
2782 | s32s46s79s97
2783 | s32s46s77s78s122
2784 | s32s46s77s78s98
2785 | s32s46s77s78s97
2786 | s32s46s63
2787 | s32s46s63s79
2788 | s32s46s63s77s78
2789 | s32s46s53
2790 | s32s46s53s79
2791 | s32s46s53s77s78
2792 | s32s46s52s122
2793 | s32s46s52s98
2794 | s32s46s52s97
2795 | s32s46s52s63
2796 | s32s46s52s53
2797 | s32s39
2798 | s32s39s115
2799 | s32s39s114
2800 | s32s39s113
2801 | s32s39s113s114
2802 | s32s39s88
2803 | s32s39s73
2804 | s32s39s73s79
2805 | s32s39s73s77s78
2806 | s32s39s71s72
2807 | s32s39s71s72s79
2808 | s32s39s71s72s77s78
2809 | s32s39s65
2810 | s32s39s63s64
2811 | s32s39s56
2812 | s32s39s55
2813 | s32s39s55s113
2814 | s32s39s54
2815 | s32s39s54s114
2816 | s32s39s54s55
2817 | s32s39s52s73
2818 | s32s39s52s71s72
2819 | s32s39s46
2820 | s32s39s46s79
2821 | s32s39s46s77s78
2822 | s32s39s46s52
2823 | s32s38s122
2824 | s32s38s115
2825 | s32s38s114
2826 | s32s38s113
2827 | s32s38s113s114
2828 | s32s38s98
2829 | s32s38s97
2830 | s32s38s88
2831 | s32s38s73
2832 | s32s38s73s79
2833 | s32s38s73s77s78
2834 | s32s38s71s72
2835 | s32s38s71s72s79
2836 | s32s38s71s72s77s78
2837 | s32s38s65
2838 | s32s38s63
2839 | s32s38s63s64
2840 | s32s38s56
2841 | s32s38s55
2842 | s32s38s55s113
2843 | s32s38s54
2844 | s32s38s54s114
2845 | s32s38s54s55
2846 | s32s38s53
2847 | s32s38s52s73
2848 | s32s38s52s71s72
2849 | s32s38s46
2850 | s32s38s46s79
2851 | s32s38s46s77s78
2852 | s32s38s46s52
2853 | s32s38s39
2854 | s31s124
2855 | s31s122
2856 | s31s115
2857 | s31s115s122
2858 | s31s114s122
2859 | s31s113s122
2860 | s31s113s114
2861 | s31s113s114s122
2862 | s31s112
2863 | s31s112s113
2864 | s31s103s122
2865 | s31s98
2866 | s31s98s115
2867 | s31s98s114
2868 | s31s98s113
2869 | s31s98s113s114
2870 | s31s98s103
2871 | s31s97s115
2872 | s31s97s114
2873 | s31s97s113
2874 | s31s97s113s114
2875 | s31s97s103
2876 | s31s94
2877 | s31s93
2878 | s31s93s122
2879 | s31s93s98
2880 | s31s93s97
2881 | s31s88
2882 | s31s88s122
2883 | s31s88s98
2884 | s31s88s97
2885 | s31s87
2886 | s31s82
2887 | s31s81
2888 | s31s80s122
2889 | s31s80s98
2890 | s31s80s97
2891 | s31s80s81
2892 | s31s79s122
2893 | s31s79s98
2894 | s31s79s97
2895 | s31s79s80
2896 | s31s78s122
2897 | s31s78s98
2898 | s31s78s97
2899 | s31s76s77s122
2900 | s31s76s77s98
2901 | s31s76s77s97
2902 | s31s76s77s79s122
2903 | s31s76s77s79s98
2904 | s31s76s77s79s97
2905 | s31s76s77s78s122
2906 | s31s76s77s78s98
2907 | s31s76s77s78s97
2908 | s31s73
2909 | s31s73s122
2910 | s31s73s98
2911 | s31s73s97
2912 | s31s73s79s122
2913 | s31s73s79s98
2914 | s31s73s79s97
2915 | s31s73s77s78s122
2916 | s31s73s77s78s98
2917 | s31s73s77s78s97
2918 | s31s71s72
2919 | s31s71s72s122
2920 | s31s71s72s98
2921 | s31s71s72s97
2922 | s31s71s72s79s122
2923 | s31s71s72s79s98
2924 | s31s71s72s79s97
2925 | s31s71s72s77s78s122
2926 | s31s71s72s77s78s98
2927 | s31s71s72s77s78s97
2928 | s31s70
2929 | s31s66
2930 | s31s64
2931 | s31s64s65
2932 | s31s63
2933 | s31s63s115
2934 | s31s63s114
2935 | s31s63s113
2936 | s31s63s113s114
2937 | s31s63s103
2938 | s31s63s93
2939 | s31s63s88
2940 | s31s63s80
2941 | s31s63s79
2942 | s31s63s78
2943 | s31s63s76s77
2944 | s31s63s76s77s79
2945 | s31s63s76s77s78
2946 | s31s63s73
2947 | s31s63s73s79
2948 | s31s63s73s77s78
2949 | s31s63s71s72
2950 | s31s63s71s72s79
2951 | s31s63s71s72s77s78
2952 | s31s63s64
2953 | s31s62s63
2954 | s31s56
2955 | s31s56s122
2956 | s31s56s98
2957 | s31s56s97
2958 | s31s56s63
2959 | s31s55s122
2960 | s31s55s113
2961 | s31s55s113s122
2962 | s31s55s98
2963 | s31s55s98s113
2964 | s31s55s97
2965 | s31s55s97s113
2966 | s31s55s63
2967 | s31s55s63s113
2968 | s31s54
2969 | s31s54s122
2970 | s31s54s114
2971 | s31s54s114s122
2972 | s31s54s112
2973 | s31s54s98
2974 | s31s54s98s114
2975 | s31s54s97
2976 | s31s54s97s114
2977 | s31s54s63
2978 | s31s54s63s114
2979 | s31s54s55
2980 | s31s54s55s122
2981 | s31s54s55s98
2982 | s31s54s55s97
2983 | s31s54s55s63
2984 | s31s53
2985 | s31s53s122
2986 | s31s53s115
2987 | s31s53s114
2988 | s31s53s113s114
2989 | s31s53s103
2990 | s31s53s98
2991 | s31s53s97
2992 | s31s53s93
2993 | s31s53s88
2994 | s31s53s80
2995 | s31s53s79
2996 | s31s53s78
2997 | s31s53s76s77
2998 | s31s53s76s77s79
2999 | s31s53s76s77s78
3000 | s31s53s73
3001 | s31s53s73s79
3002 | s31s53s73s77s78
3003 | s31s53s71s72
3004 | s31s53s71s72s79
3005 | s31s53s71s72s77s78
3006 | s31s53s63
3007 | s31s53s56
3008 | s31s53s55
3009 | s31s53s55s113
3010 | s31s53s54s114
3011 | s31s53s54s55
3012 | s31s52s122
3013 | s31s52s98
3014 | s31s52s97
3015 | s31s52s78s122
3016 | s31s52s78s98
3017 | s31s52s78s97
3018 | s31s52s76s77s122
3019 | s31s52s76s77s98
3020 | s31s52s76s77s97
3021 | s31s52s73s122
3022 | s31s52s73s98
3023 | s31s52s73s97
3024 | s31s52s71s72s122
3025 | s31s52s71s72s98
3026 | s31s52s71s72s97
3027 | s31s52s63
3028 | s31s52s63s78
3029 | s31s52s63s76s77
3030 | s31s52s63s73
3031 | s31s52s63s71s72
3032 | s31s52s53
3033 | s31s52s53s78
3034 | s31s52s53s76s77
3035 | s31s52s53s73
3036 | s31s52s53s71s72
3037 | s31s51s122
3038 | s31s51s98
3039 | s31s51s97
3040 | s31s51s79s122
3041 | s31s51s79s98
3042 | s31s51s79s97
3043 | s31s51s77s78s122
3044 | s31s51s77s78s98
3045 | s31s51s77s78s97
3046 | s31s51s63
3047 | s31s51s63s79
3048 | s31s51s63s77s78
3049 | s31s51s53
3050 | s31s51s53s79
3051 | s31s51s53s77s78
3052 | s31s51s52s122
3053 | s31s51s52s98
3054 | s31s51s52s97
3055 | s31s51s52s63
3056 | s31s51s52s53
3057 | s31s46
3058 | s31s46s122
3059 | s31s46s98
3060 | s31s46s97
3061 | s31s46s79s122
3062 | s31s46s79s98
3063 | s31s46s79s97
3064 | s31s46s77s78s122
3065 | s31s46s77s78s98
3066 | s31s46s77s78s97
3067 | s31s46s63
3068 | s31s46s63s79
3069 | s31s46s63s77s78
3070 | s31s46s53
3071 | s31s46s53s79
3072 | s31s46s53s77s78
3073 | s31s46s52s122
3074 | s31s46s52s98
3075 | s31s46s52s97
3076 | s31s46s52s63
3077 | s31s46s52s53
3078 | s31s44s122
3079 | s31s44s98
3080 | s31s44s97
3081 | s31s44s63
3082 | s31s44s53
3083 | s31s39s115
3084 | s31s39s114
3085 | s31s39s113
3086 | s31s39s113s114
3087 | s31s39s103
3088 | s31s39s93
3089 | s31s39s88
3090 | s31s39s80
3091 | s31s39s79
3092 | s31s39s78
3093 | s31s39s76s77
3094 | s31s39s76s77s79
3095 | s31s39s76s77s78
3096 | s31s39s73
3097 | s31s39s73s79
3098 | s31s39s73s77s78
3099 | s31s39s71s72
3100 | s31s39s71s72s79
3101 | s31s39s71s72s77s78
3102 | s31s39s56
3103 | s31s39s55
3104 | s31s39s55s113
3105 | s31s39s54
3106 | s31s39s54s114
3107 | s31s39s54s55
3108 | s31s39s53
3109 | s31s39s52
3110 | s31s39s52s78
3111 | s31s39s52s76s77
3112 | s31s39s52s73
3113 | s31s39s52s71s72
3114 | s31s39s51
3115 | s31s39s51s79
3116 | s31s39s51s77s78
3117 | s31s39s51s52
3118 | s31s39s46
3119 | s31s39s46s79
3120 | s31s39s46s77s78
3121 | s31s39s46s52
3122 | s31s39s44
3123 | s31s38
3124 | s31s38s115
3125 | s31s38s114
3126 | s31s38s113
3127 | s31s38s113s114
3128 | s31s38s103
3129 | s31s38s93
3130 | s31s38s88
3131 | s31s38s80
3132 | s31s38s79
3133 | s31s38s78
3134 | s31s38s76s77
3135 | s31s38s76s77s79
3136 | s31s38s76s77s78
3137 | s31s38s73
3138 | s31s38s73s79
3139 | s31s38s73s77s78
3140 | s31s38s71s72
3141 | s31s38s71s72s79
3142 | s31s38s71s72s77s78
3143 | s31s38s56
3144 | s31s38s55
3145 | s31s38s55s113
3146 | s31s38s54
3147 | s31s38s54s114
3148 | s31s38s54s55
3149 | s31s38s53
3150 | s31s38s52
3151 | s31s38s52s78
3152 | s31s38s52s76s77
3153 | s31s38s52s73
3154 | s31s38s52s71s72
3155 | s31s38s51
3156 | s31s38s51s79
3157 | s31s38s51s77s78
3158 | s31s38s51s52
3159 | s31s38s46
3160 | s31s38s46s79
3161 | s31s38s46s77s78
3162 | s31s38s46s52
3163 | s31s38s44
3164 | s31s37
3165 | s31s35
3166 | s31s34
3167 | s31s34s122
3168 | s31s34s98
3169 | s31s34s97
3170 | s31s34s63
3171 | s31s34s53
3172 | s31s34s39
3173 | s31s34s38
3174 | s30s126
3175 | s30s124
3176 | s30s122
3177 | s30s115s122
3178 | s30s114s122
3179 | s30s113s122
3180 | s30s113s114s122
3181 | s30s98
3182 | s30s98s115
3183 | s30s98s114
3184 | s30s98s113
3185 | s30s98s113s114
3186 | s30s97
3187 | s30s97s115
3188 | s30s97s114
3189 | s30s97s113
3190 | s30s97s113s114
3191 | s30s93
3192 | s30s91
3193 | s30s90
3194 | s30s89s90
3195 | s30s88s122
3196 | s30s88s98
3197 | s30s88s97
3198 | s30s88s89
3199 | s30s87
3200 | s30s86
3201 | s30s84s85
3202 | s30s81
3203 | s30s80
3204 | s30s78s79
3205 | s30s73
3206 | s30s73s122
3207 | s30s73s98
3208 | s30s73s97
3209 | s30s73s79s122
3210 | s30s73s79s98
3211 | s30s73s79s97
3212 | s30s73s77s78s122
3213 | s30s73s77s78s98
3214 | s30s73s77s78s97
3215 | s30s71s72
3216 | s30s71s72s122
3217 | s30s71s72s98
3218 | s30s71s72s97
3219 | s30s71s72s79s122
3220 | s30s71s72s79s98
3221 | s30s71s72s79s97
3222 | s30s71s72s77s78s122
3223 | s30s71s72s77s78s98
3224 | s30s71s72s77s78s97
3225 | s30s69
3226 | s30s67
3227 | s30s65
3228 | s30s65s122
3229 | s30s65s98
3230 | s30s65s97
3231 | s30s64
3232 | s30s63s115
3233 | s30s63s114
3234 | s30s63s113
3235 | s30s63s113s114
3236 | s30s63s88
3237 | s30s63s73
3238 | s30s63s73s79
3239 | s30s63s73s77s78
3240 | s30s63s71s72
3241 | s30s63s71s72s79
3242 | s30s63s71s72s77s78
3243 | s30s63s65
3244 | s30s63s64
3245 | s30s63s64s122
3246 | s30s63s64s98
3247 | s30s63s64s97
3248 | s30s59
3249 | s30s57
3250 | s30s56s122
3251 | s30s56s98
3252 | s30s56s97
3253 | s30s56s63
3254 | s30s55s122
3255 | s30s55s113s122
3256 | s30s55s98
3257 | s30s55s98s113
3258 | s30s55s97
3259 | s30s55s97s113
3260 | s30s55s63
3261 | s30s55s63s113
3262 | s30s54s114s122
3263 | s30s54s98s114
3264 | s30s54s97s114
3265 | s30s54s63s114
3266 | s30s54s55s122
3267 | s30s54s55s98
3268 | s30s54s55s97
3269 | s30s54s55s63
3270 | s30s53s115
3271 | s30s53s114
3272 | s30s53s113
3273 | s30s53s113s114
3274 | s30s53s88
3275 | s30s53s73
3276 | s30s53s73s79
3277 | s30s53s73s77s78
3278 | s30s53s71s72
3279 | s30s53s71s72s79
3280 | s30s53s71s72s77s78
3281 | s30s53s65
3282 | s30s53s63s64
3283 | s30s53s56
3284 | s30s53s55
3285 | s30s53s55s113
3286 | s30s53s54
3287 | s30s53s54s114
3288 | s30s53s54s55
3289 | s30s52s73s122
3290 | s30s52s73s98
3291 | s30s52s73s97
3292 | s30s52s71s72s122
3293 | s30s52s71s72s98
3294 | s30s52s71s72s97
3295 | s30s52s63s73
3296 | s30s52s63s71s72
3297 | s30s52s53
3298 | s30s52s53s122
3299 | s30s52s53s98
3300 | s30s52s53s97
3301 | s30s52s53s73
3302 | s30s52s53s71s72
3303 | s30s52s53s63
3304 | s30s47
3305 | s30s46
3306 | s30s46s122
3307 | s30s46s98
3308 | s30s46s97
3309 | s30s46s79s122
3310 | s30s46s79s98
3311 | s30s46s79s97
3312 | s30s46s77s78s122
3313 | s30s46s77s78s98
3314 | s30s46s77s78s97
3315 | s30s46s63
3316 | s30s46s63s79
3317 | s30s46s63s77s78
3318 | s30s46s53
3319 | s30s46s53s79
3320 | s30s46s53s77s78
3321 | s30s46s52s122
3322 | s30s46s52s98
3323 | s30s46s52s97
3324 | s30s46s52s63
3325 | s30s46s52s53
3326 | s30s45s46
3327 | s30s39
3328 | s30s39s115
3329 | s30s39s114
3330 | s30s39s113
3331 | s30s39s113s114
3332 | s30s39s88
3333 | s30s39s73
3334 | s30s39s73s79
3335 | s30s39s73s77s78
3336 | s30s39s71s72
3337 | s30s39s71s72s79
3338 | s30s39s71s72s77s78
3339 | s30s39s65
3340 | s30s39s63s64
3341 | s30s39s56
3342 | s30s39s55
3343 | s30s39s55s113
3344 | s30s39s54s114
3345 | s30s39s54s55
3346 | s30s39s52s73
3347 | s30s39s52s71s72
3348 | s30s39s52s53
3349 | s30s39s46
3350 | s30s39s46s79
3351 | s30s39s46s77s78
3352 | s30s39s46s52
3353 | s30s38s122
3354 | s30s38s115
3355 | s30s38s114
3356 | s30s38s113
3357 | s30s38s113s114
3358 | s30s38s98
3359 | s30s38s97
3360 | s30s38s88
3361 | s30s38s73
3362 | s30s38s73s79
3363 | s30s38s73s77s78
3364 | s30s38s71s72
3365 | s30s38s71s72s79
3366 | s30s38s71s72s77s78
3367 | s30s38s65
3368 | s30s38s63
3369 | s30s38s63s64
3370 | s30s38s56
3371 | s30s38s55
3372 | s30s38s55s113
3373 | s30s38s54s114
3374 | s30s38s54s55
3375 | s30s38s53
3376 | s30s38s52s73
3377 | s30s38s52s71s72
3378 | s30s38s52s53
3379 | s30s38s46
3380 | s30s38s46s79
3381 | s30s38s46s77s78
3382 | s30s38s46s52
3383 | s30s38s39
3384 | s30s34
3385 | s29
3386 | s29s124
3387 | s29s98
3388 | s29s91
3389 | s29s91s122
3390 | s29s91s98
3391 | s29s91s97
3392 | s29s90s122
3393 | s29s90s98
3394 | s29s90s97
3395 | s29s89s122
3396 | s29s89s98
3397 | s29s89s97
3398 | s29s89s90
3399 | s29s86
3400 | s29s84s85
3401 | s29s80
3402 | s29s78s122
3403 | s29s78s98
3404 | s29s78s97
3405 | s29s78s79
3406 | s29s76s77s122
3407 | s29s76s77s98
3408 | s29s76s77s97
3409 | s29s73
3410 | s29s71s72
3411 | s29s68
3412 | s29s66
3413 | s29s64
3414 | s29s64s65
3415 | s29s63s91
3416 | s29s63s90
3417 | s29s63s89
3418 | s29s63s78
3419 | s29s63s76s77
3420 | s29s63s64
3421 | s29s59
3422 | s29s55
3423 | s29s54s122
3424 | s29s54s98
3425 | s29s54s97
3426 | s29s54s63
3427 | s29s53
3428 | s29s53s91
3429 | s29s53s90
3430 | s29s53s89
3431 | s29s53s78
3432 | s29s53s76s77
3433 | s29s53s54
3434 | s29s52s53
3435 | s29s52s53s122
3436 | s29s52s53s98
3437 | s29s52s53s97
3438 | s29s52s53s63
3439 | s29s51s122
3440 | s29s51s98
3441 | s29s51s97
3442 | s29s51s63
3443 | s29s51s53
3444 | s29s46
3445 | s29s39s91
3446 | s29s39s90
3447 | s29s39s89
3448 | s29s39s78
3449 | s29s39s76s77
3450 | s29s39s54
3451 | s29s39s52s53
3452 | s29s39s51
3453 | s29s38
3454 | s29s38s91
3455 | s29s38s90
3456 | s29s38s89
3457 | s29s38s78
3458 | s29s38s76s77
3459 | s29s38s54
3460 | s29s38s52s53
3461 | s29s38s51
3462 | s29s32s122
3463 | s29s32s98
3464 | s29s32s97
3465 | s29s32s63
3466 | s29s32s53
3467 | s29s32s39
3468 | s29s32s38
3469 | s29s31s122
3470 | s29s31s98
3471 | s29s31s97
3472 | s29s31s63
3473 | s29s31s53
3474 | s29s31s39
3475 | s29s31s38
3476 | s29s30s122
3477 | s29s30s98
3478 | s29s30s97
3479 | s29s30s63
3480 | s29s30s53
3481 | s29s30s39
3482 | s29s30s38
3483 | s28s125
3484 | s28s124
3485 | s28s122
3486 | s28s120
3487 | s28s115
3488 | s28s114
3489 | s28s113
3490 | s28s113s114
3491 | s28s101
3492 | s28s100
3493 | s28s99s100
3494 | s28s98
3495 | s28s92s98
3496 | s28s90s91
3497 | s28s90s91s98
3498 | s28s88s89
3499 | s28s81
3500 | s28s79
3501 | s28s79s80
3502 | s28s74
3503 | s28s73
3504 | s28s71s72
3505 | s28s69
3506 | s28s67
3507 | s28s67s98
3508 | s28s66
3509 | s28s66s98
3510 | s28s65
3511 | s28s65s98
3512 | s28s65s66
3513 | s28s65s66s98
3514 | s28s64s65s98
3515 | s28s63s64
3516 | s28s61
3517 | s28s55s113
3518 | s28s54s114
3519 | s28s54s73
3520 | s28s54s71s72
3521 | s28s54s55
3522 | s28s53
3523 | s28s52s53s73
3524 | s28s52s53s71s72
3525 | s28s49s50
3526 | s28s46
3527 | s28s46s54
3528 | s28s46s52s53
3529 | s28s42
3530 | s28s41
3531 | s28s41s99
3532 | s28s40
3533 | s28s40s100
3534 | s28s40s98
3535 | s28s40s41
3536 | s28s39s98
3537 | s28s39s92
3538 | s28s39s90s91
3539 | s28s39s67
3540 | s28s39s66
3541 | s28s39s65
3542 | s28s39s65s66
3543 | s28s39s64s65
3544 | s28s39s40
3545 | s28s38
3546 | s28s33
3547 | s28s31
3548 | s27s115s122
3549 | s27s114s122
3550 | s27s113s122
3551 | s27s113s114s122
3552 | s27s98
3553 | s27s98s115
3554 | s27s98s114
3555 | s27s98s113
3556 | s27s98s113s114
3557 | s27s97s115
3558 | s27s97s114
3559 | s27s97s113
3560 | s27s97s113s114
3561 | s27s96
3562 | s27s92
3563 | s27s90s91
3564 | s27s89s122
3565 | s27s89s98
3566 | s27s89s97
3567 | s27s88s122
3568 | s27s88s98
3569 | s27s88s97
3570 | s27s82
3571 | s27s80
3572 | s27s80s98
3573 | s27s80s81
3574 | s27s73s122
3575 | s27s73s98
3576 | s27s73s97
3577 | s27s73s79s122
3578 | s27s73s79s98
3579 | s27s73s79s97
3580 | s27s73s77s78s122
3581 | s27s73s77s78s98
3582 | s27s73s77s78s97
3583 | s27s71s72s122
3584 | s27s71s72s98
3585 | s27s71s72s97
3586 | s27s71s72s79s122
3587 | s27s71s72s79s98
3588 | s27s71s72s79s97
3589 | s27s71s72s77s78s122
3590 | s27s71s72s77s78s98
3591 | s27s71s72s77s78s97
3592 | s27s69
3593 | s27s67
3594 | s27s66
3595 | s27s65
3596 | s27s65s122
3597 | s27s65s98
3598 | s27s65s97
3599 | s27s65s66
3600 | s27s64s65
3601 | s27s63s115
3602 | s27s63s114
3603 | s27s63s113
3604 | s27s63s113s114
3605 | s27s63s89
3606 | s27s63s88
3607 | s27s63s73
3608 | s27s63s73s79
3609 | s27s63s73s77s78
3610 | s27s63s71s72
3611 | s27s63s71s72s79
3612 | s27s63s71s72s77s78
3613 | s27s63s65
3614 | s27s63s64
3615 | s27s63s64s122
3616 | s27s63s64s98
3617 | s27s63s64s97
3618 | s27s56s122
3619 | s27s56s98
3620 | s27s56s97
3621 | s27s56s63
3622 | s27s55
3623 | s27s55s122
3624 | s27s55s113s122
3625 | s27s55s98
3626 | s27s55s98s113
3627 | s27s55s97
3628 | s27s55s97s113
3629 | s27s55s73
3630 | s27s55s71s72
3631 | s27s55s63
3632 | s27s55s63s113
3633 | s27s54s122
3634 | s27s54s114s122
3635 | s27s54s98
3636 | s27s54s98s114
3637 | s27s54s97
3638 | s27s54s97s114
3639 | s27s54s63
3640 | s27s54s63s114
3641 | s27s54s55s122
3642 | s27s54s55s98
3643 | s27s54s55s97
3644 | s27s54s55s63
3645 | s27s53s115
3646 | s27s53s114
3647 | s27s53s113
3648 | s27s53s113s114
3649 | s27s53s89
3650 | s27s53s88
3651 | s27s53s73
3652 | s27s53s73s79
3653 | s27s53s73s77s78
3654 | s27s53s71s72
3655 | s27s53s71s72s79
3656 | s27s53s71s72s77s78
3657 | s27s53s65
3658 | s27s53s63s64
3659 | s27s53s56
3660 | s27s53s55
3661 | s27s53s55s113
3662 | s27s53s54
3663 | s27s53s54s114
3664 | s27s53s54s73
3665 | s27s53s54s71s72
3666 | s27s53s54s55
3667 | s27s52s73s122
3668 | s27s52s73s98
3669 | s27s52s73s97
3670 | s27s52s71s72s122
3671 | s27s52s71s72s98
3672 | s27s52s71s72s97
3673 | s27s52s63s73
3674 | s27s52s63s71s72
3675 | s27s52s53s73
3676 | s27s52s53s71s72
3677 | s27s46s122
3678 | s27s46s98
3679 | s27s46s97
3680 | s27s46s79s122
3681 | s27s46s79s98
3682 | s27s46s79s97
3683 | s27s46s77s78s122
3684 | s27s46s77s78s98
3685 | s27s46s77s78s97
3686 | s27s46s63
3687 | s27s46s63s79
3688 | s27s46s63s77s78
3689 | s27s46s55
3690 | s27s46s53
3691 | s27s46s53s79
3692 | s27s46s53s77s78
3693 | s27s46s53s54
3694 | s27s46s52s122
3695 | s27s46s52s98
3696 | s27s46s52s97
3697 | s27s46s52s63
3698 | s27s46s52s53
3699 | s27s40
3700 | s27s39s115
3701 | s27s39s114
3702 | s27s39s113
3703 | s27s39s113s114
3704 | s27s39s89
3705 | s27s39s88
3706 | s27s39s80
3707 | s27s39s73
3708 | s27s39s73s79
3709 | s27s39s73s77s78
3710 | s27s39s71s72
3711 | s27s39s71s72s79
3712 | s27s39s71s72s77s78
3713 | s27s39s65
3714 | s27s39s63s64
3715 | s27s39s56
3716 | s27s39s55
3717 | s27s39s55s113
3718 | s27s39s54
3719 | s27s39s54s114
3720 | s27s39s54s55
3721 | s27s39s52s73
3722 | s27s39s52s71s72
3723 | s27s39s46
3724 | s27s39s46s79
3725 | s27s39s46s77s78
3726 | s27s39s46s52
3727 | s27s38
3728 | s27s38s122
3729 | s27s38s115
3730 | s27s38s114
3731 | s27s38s113
3732 | s27s38s113s114
3733 | s27s38s98
3734 | s27s38s97
3735 | s27s38s89
3736 | s27s38s88
3737 | s27s38s73
3738 | s27s38s73s79
3739 | s27s38s73s77s78
3740 | s27s38s71s72
3741 | s27s38s71s72s79
3742 | s27s38s71s72s77s78
3743 | s27s38s65
3744 | s27s38s63
3745 | s27s38s63s64
3746 | s27s38s56
3747 | s27s38s55
3748 | s27s38s55s113
3749 | s27s38s54
3750 | s27s38s54s114
3751 | s27s38s54s55
3752 | s27s38s53
3753 | s27s38s52s73
3754 | s27s38s52s71s72
3755 | s27s38s46
3756 | s27s38s46s79
3757 | s27s38s46s77s78
3758 | s27s38s46s52
3759 | s27s38s39
3760 | s27s37
3761 | s27s30s122
3762 | s27s30s98
3763 | s27s30s97
3764 | s27s30s63
3765 | s27s30s53
3766 | s27s30s39
3767 | s27s30s38
3768 | s27s29s122
3769 | s27s29s98
3770 | s27s29s97
3771 | s27s29s63
3772 | s27s29s53
3773 | s27s29s39
3774 | s27s29s38
3775 | s27s28
3776 | s27s28s90
3777 | s27s28s67
3778 | s27s28s65s66
3779 | s27s28s40
3780 | s27s28s31
3781 | s26
3782 | s26s89
3783 | s26s89s96
3784 | s26s37s89
3785 | s26s30
3786 | s26s30s96
3787 | s26s30s37
3788 | s26s27
3789 | s25s96
3790 | s25s90
3791 | s25s73
3792 | s25s71s72
3793 | s25s46
3794 | s25s37
3795 | s25s31
3796 | s24
3797 | s24s96
3798 | s24s90
3799 | s24s89
3800 | s24s73
3801 | s24s71s72
3802 | s24s55
3803 | s24s53s54
3804 | s24s46
3805 | s24s37
3806 | s24s31
3807 | s24s30
3808 | s24s28
3809 | s23s102
3810 | s23s73
3811 | s23s71s72
3812 | s23s66
3813 | s23s64s65
3814 | s23s55
3815 | s23s53s54
3816 | s23s46
3817 | s23s43
3818 | s23s39
3819 | s23s33
3820 | s23s28
3821 | s22s126
3822 | s22s122
3823 | s22s115s122
3824 | s22s114s122
3825 | s22s113s122
3826 | s22s113s114s122
3827 | s22s98s115
3828 | s22s98s114
3829 | s22s98s113
3830 | s22s98s113s114
3831 | s22s97
3832 | s22s97s115
3833 | s22s97s114
3834 | s22s97s113
3835 | s22s97s113s114
3836 | s22s91
3837 | s22s89
3838 | s22s88s122
3839 | s22s88s98
3840 | s22s88s97
3841 | s22s81
3842 | s22s77
3843 | s22s73s122
3844 | s22s73s98
3845 | s22s73s97
3846 | s22s73s79s122
3847 | s22s73s79s98
3848 | s22s73s79s97
3849 | s22s73s77s78s122
3850 | s22s73s77s78s98
3851 | s22s73s77s78s97
3852 | s22s71s72s122
3853 | s22s71s72s98
3854 | s22s71s72s97
3855 | s22s71s72s79s122
3856 | s22s71s72s79s98
3857 | s22s71s72s79s97
3858 | s22s71s72s77s78s122
3859 | s22s71s72s77s78s98
3860 | s22s71s72s77s78s97
3861 | s22s67
3862 | s22s66
3863 | s22s65s122
3864 | s22s65s98
3865 | s22s65s97
3866 | s22s64s65
3867 | s22s63
3868 | s22s63s115
3869 | s22s63s114
3870 | s22s63s113
3871 | s22s63s113s114
3872 | s22s63s88
3873 | s22s63s73
3874 | s22s63s73s79
3875 | s22s63s73s77s78
3876 | s22s63s71s72
3877 | s22s63s71s72s79
3878 | s22s63s71s72s77s78
3879 | s22s63s65
3880 | s22s63s64
3881 | s22s63s64s122
3882 | s22s63s64s98
3883 | s22s63s64s97
3884 | s22s57
3885 | s22s56s122
3886 | s22s56s98
3887 | s22s56s97
3888 | s22s56s63
3889 | s22s55s122
3890 | s22s55s113s122
3891 | s22s55s98
3892 | s22s55s98s113
3893 | s22s55s97
3894 | s22s55s97s113
3895 | s22s55s63
3896 | s22s55s63s113
3897 | s22s54s122
3898 | s22s54s114s122
3899 | s22s54s98
3900 | s22s54s98s114
3901 | s22s54s97
3902 | s22s54s97s114
3903 | s22s54s63
3904 | s22s54s63s114
3905 | s22s54s55s122
3906 | s22s54s55s98
3907 | s22s54s55s97
3908 | s22s54s55s63
3909 | s22s53
3910 | s22s53s115
3911 | s22s53s114
3912 | s22s53s113
3913 | s22s53s113s114
3914 | s22s53s88
3915 | s22s53s73
3916 | s22s53s73s79
3917 | s22s53s73s77s78
3918 | s22s53s71s72
3919 | s22s53s71s72s79
3920 | s22s53s71s72s77s78
3921 | s22s53s65
3922 | s22s53s63s64
3923 | s22s53s56
3924 | s22s53s55
3925 | s22s53s55s113
3926 | s22s53s54
3927 | s22s53s54s114
3928 | s22s53s54s55
3929 | s22s52s73s122
3930 | s22s52s73s98
3931 | s22s52s73s97
3932 | s22s52s71s72s122
3933 | s22s52s71s72s98
3934 | s22s52s71s72s97
3935 | s22s52s63s73
3936 | s22s52s63s71s72
3937 | s22s52s53s73
3938 | s22s52s53s71s72
3939 | s22s46s122
3940 | s22s46s98
3941 | s22s46s97
3942 | s22s46s79s122
3943 | s22s46s79s98
3944 | s22s46s79s97
3945 | s22s46s77s78s122
3946 | s22s46s77s78s98
3947 | s22s46s77s78s97
3948 | s22s46s63
3949 | s22s46s63s79
3950 | s22s46s63s77s78
3951 | s22s46s53
3952 | s22s46s53s79
3953 | s22s46s53s77s78
3954 | s22s46s52s122
3955 | s22s46s52s98
3956 | s22s46s52s97
3957 | s22s46s52s63
3958 | s22s46s52s53
3959 | s22s39
3960 | s22s39s115
3961 | s22s39s114
3962 | s22s39s113
3963 | s22s39s113s114
3964 | s22s39s88
3965 | s22s39s73
3966 | s22s39s73s79
3967 | s22s39s73s77s78
3968 | s22s39s71s72
3969 | s22s39s71s72s79
3970 | s22s39s71s72s77s78
3971 | s22s39s65
3972 | s22s39s63s64
3973 | s22s39s56
3974 | s22s39s55
3975 | s22s39s55s113
3976 | s22s39s54
3977 | s22s39s54s114
3978 | s22s39s54s55
3979 | s22s39s52s73
3980 | s22s39s52s71s72
3981 | s22s39s46
3982 | s22s39s46s79
3983 | s22s39s46s77s78
3984 | s22s39s46s52
3985 | s22s38s122
3986 | s22s38s115
3987 | s22s38s114
3988 | s22s38s113
3989 | s22s38s113s114
3990 | s22s38s98
3991 | s22s38s97
3992 | s22s38s88
3993 | s22s38s73
3994 | s22s38s73s79
3995 | s22s38s73s77s78
3996 | s22s38s71s72
3997 | s22s38s71s72s79
3998 | s22s38s71s72s77s78
3999 | s22s38s65
4000 | s22s38s63
4001 | s22s38s63s64
4002 | s22s38s56
4003 | s22s38s55
4004 | s22s38s55s113
4005 | s22s38s54
4006 | s22s38s54s114
4007 | s22s38s54s55
4008 | s22s38s53
4009 | s22s38s52s73
4010 | s22s38s52s71s72
4011 | s22s38s46
4012 | s22s38s46s79
4013 | s22s38s46s77s78
4014 | s22s38s46s52
4015 | s22s38s39
4016 | s22s32
4017 | s22s30
4018 | s22s29s122
4019 | s22s29s98
4020 | s22s29s97
4021 | s22s29s63
4022 | s22s29s53
4023 | s22s29s39
4024 | s22s29s38
4025 | s21s124
4026 | s21s122
4027 | s21s115
4028 | s21s115s122
4029 | s21s114
4030 | s21s114s122
4031 | s21s113
4032 | s21s113s122
4033 | s21s113s114
4034 | s21s113s114s122
4035 | s21s103s122
4036 | s21s98s115
4037 | s21s98s114
4038 | s21s98s113
4039 | s21s98s113s114
4040 | s21s98s103
4041 | s21s97s115
4042 | s21s97s114
4043 | s21s97s113
4044 | s21s97s113s114
4045 | s21s97s103
4046 | s21s94
4047 | s21s93
4048 | s21s93s122
4049 | s21s93s98
4050 | s21s93s97
4051 | s21s88
4052 | s21s88s122
4053 | s21s88s98
4054 | s21s88s97
4055 | s21s82
4056 | s21s81
4057 | s21s80s122
4058 | s21s80s98
4059 | s21s80s97
4060 | s21s80s81
4061 | s21s79s122
4062 | s21s79s98
4063 | s21s79s97
4064 | s21s79s80
4065 | s21s78s122
4066 | s21s78s98
4067 | s21s78s97
4068 | s21s76s77s122
4069 | s21s76s77s98
4070 | s21s76s77s97
4071 | s21s76s77s79s122
4072 | s21s76s77s79s98
4073 | s21s76s77s79s97
4074 | s21s76s77s78s122
4075 | s21s76s77s78s98
4076 | s21s76s77s78s97
4077 | s21s73
4078 | s21s73s122
4079 | s21s73s98
4080 | s21s73s97
4081 | s21s73s79s122
4082 | s21s73s79s98
4083 | s21s73s79s97
4084 | s21s73s77s78s122
4085 | s21s73s77s78s98
4086 | s21s73s77s78s97
4087 | s21s71s72
4088 | s21s71s72s122
4089 | s21s71s72s98
4090 | s21s71s72s97
4091 | s21s71s72s79s122
4092 | s21s71s72s79s98
4093 | s21s71s72s79s97
4094 | s21s71s72s77s78s122
4095 | s21s71s72s77s78s98
4096 | s21s71s72s77s78s97
4097 | s21s63
4098 | s21s63s115
4099 | s21s63s114
4100 | s21s63s113
4101 | s21s63s113s114
4102 | s21s63s103
4103 | s21s63s93
4104 | s21s63s88
4105 | s21s63s80
4106 | s21s63s79
4107 | s21s63s78
4108 | s21s63s76s77
4109 | s21s63s76s77s79
4110 | s21s63s76s77s78
4111 | s21s63s73
4112 | s21s63s73s79
4113 | s21s63s73s77s78
4114 | s21s63s71s72
4115 | s21s63s71s72s79
4116 | s21s63s71s72s77s78
4117 | s21s63s64
4118 | s21s56
4119 | s21s56s122
4120 | s21s56s98
4121 | s21s56s97
4122 | s21s56s63
4123 | s21s55
4124 | s21s55s122
4125 | s21s55s113
4126 | s21s55s113s122
4127 | s21s55s98
4128 | s21s55s98s113
4129 | s21s55s97
4130 | s21s55s97s113
4131 | s21s55s63
4132 | s21s55s63s113
4133 | s21s54
4134 | s21s54s122
4135 | s21s54s114
4136 | s21s54s114s122
4137 | s21s54s98s114
4138 | s21s54s97
4139 | s21s54s97s114
4140 | s21s54s63
4141 | s21s54s63s114
4142 | s21s54s55
4143 | s21s54s55s122
4144 | s21s54s55s98
4145 | s21s54s55s97
4146 | s21s54s55s63
4147 | s21s53s122
4148 | s21s53s115
4149 | s21s53s114
4150 | s21s53s113
4151 | s21s53s113s114
4152 | s21s53s103
4153 | s21s53s98
4154 | s21s53s97
4155 | s21s53s93
4156 | s21s53s88
4157 | s21s53s80
4158 | s21s53s79
4159 | s21s53s78
4160 | s21s53s76s77
4161 | s21s53s76s77s79
4162 | s21s53s76s77s78
4163 | s21s53s73
4164 | s21s53s73s79
4165 | s21s53s73s77s78
4166 | s21s53s71s72
4167 | s21s53s71s72s79
4168 | s21s53s71s72s77s78
4169 | s21s53s63
4170 | s21s53s56
4171 | s21s53s55
4172 | s21s53s55s113
4173 | s21s53s54
4174 | s21s53s54s114
4175 | s21s53s54s55
4176 | s21s52s122
4177 | s21s52s98
4178 | s21s52s97
4179 | s21s52s78s122
4180 | s21s52s78s98
4181 | s21s52s78s97
4182 | s21s52s76s77s122
4183 | s21s52s76s77s98
4184 | s21s52s76s77s97
4185 | s21s52s73s122
4186 | s21s52s73s98
4187 | s21s52s73s97
4188 | s21s52s71s72s122
4189 | s21s52s71s72s98
4190 | s21s52s71s72s97
4191 | s21s52s63
4192 | s21s52s63s78
4193 | s21s52s63s76s77
4194 | s21s52s63s73
4195 | s21s52s63s71s72
4196 | s21s52s53s98
4197 | s21s52s53s78
4198 | s21s52s53s76s77
4199 | s21s52s53s73
4200 | s21s52s53s71s72
4201 | s21s51s122
4202 | s21s51s98
4203 | s21s51s97
4204 | s21s51s79s122
4205 | s21s51s79s98
4206 | s21s51s79s97
4207 | s21s51s77s78s122
4208 | s21s51s77s78s98
4209 | s21s51s77s78s97
4210 | s21s51s63
4211 | s21s51s63s79
4212 | s21s51s63s77s78
4213 | s21s51s53
4214 | s21s51s53s79
4215 | s21s51s53s77s78
4216 | s21s51s52s122
4217 | s21s51s52s98
4218 | s21s51s52s97
4219 | s21s51s52s63
4220 | s21s51s52s53
4221 | s21s46
4222 | s21s46s122
4223 | s21s46s98
4224 | s21s46s97
4225 | s21s46s79s122
4226 | s21s46s79s98
4227 | s21s46s79s97
4228 | s21s46s77s78s122
4229 | s21s46s77s78s98
4230 | s21s46s77s78s97
4231 | s21s46s63
4232 | s21s46s63s79
4233 | s21s46s63s77s78
4234 | s21s46s53
4235 | s21s46s53s79
4236 | s21s46s53s77s78
4237 | s21s46s52s122
4238 | s21s46s52s98
4239 | s21s46s52s97
4240 | s21s46s52s63
4241 | s21s46s52s53
4242 | s21s44s122
4243 | s21s44s98
4244 | s21s44s97
4245 | s21s44s63
4246 | s21s44s53
4247 | s21s39s115
4248 | s21s39s114
4249 | s21s39s113
4250 | s21s39s113s114
4251 | s21s39s103
4252 | s21s39s93
4253 | s21s39s88
4254 | s21s39s80
4255 | s21s39s79
4256 | s21s39s78
4257 | s21s39s76s77
4258 | s21s39s76s77s79
4259 | s21s39s76s77s78
4260 | s21s39s73
4261 | s21s39s73s79
4262 | s21s39s73s77s78
4263 | s21s39s71s72
4264 | s21s39s71s72s79
4265 | s21s39s71s72s77s78
4266 | s21s39s56
4267 | s21s39s55
4268 | s21s39s55s113
4269 | s21s39s54s114
4270 | s21s39s54s55
4271 | s21s39s53
4272 | s21s39s52
4273 | s21s39s52s78
4274 | s21s39s52s76s77
4275 | s21s39s52s73
4276 | s21s39s52s71s72
4277 | s21s39s52s53
4278 | s21s39s51
4279 | s21s39s51s79
4280 | s21s39s51s77s78
4281 | s21s39s51s52
4282 | s21s39s46
4283 | s21s39s46s79
4284 | s21s39s46s77s78
4285 | s21s39s46s52
4286 | s21s39s44
4287 | s21s38
4288 | s21s38s115
4289 | s21s38s114
4290 | s21s38s113
4291 | s21s38s113s114
4292 | s21s38s103
4293 | s21s38s93
4294 | s21s38s88
4295 | s21s38s80
4296 | s21s38s79
4297 | s21s38s78
4298 | s21s38s76s77
4299 | s21s38s76s77s79
4300 | s21s38s76s77s78
4301 | s21s38s73
4302 | s21s38s73s79
4303 | s21s38s73s77s78
4304 | s21s38s71s72
4305 | s21s38s71s72s79
4306 | s21s38s71s72s77s78
4307 | s21s38s56
4308 | s21s38s55
4309 | s21s38s55s113
4310 | s21s38s54
4311 | s21s38s54s114
4312 | s21s38s54s55
4313 | s21s38s53
4314 | s21s38s52
4315 | s21s38s52s78
4316 | s21s38s52s76s77
4317 | s21s38s52s73
4318 | s21s38s52s71s72
4319 | s21s38s51
4320 | s21s38s51s79
4321 | s21s38s51s77s78
4322 | s21s38s51s52
4323 | s21s38s46
4324 | s21s38s46s79
4325 | s21s38s46s77s78
4326 | s21s38s46s52
4327 | s21s38s44
4328 | s21s35
4329 | s21s34
4330 | s21s34s122
4331 | s21s34s98
4332 | s21s34s97
4333 | s21s34s63
4334 | s21s34s53
4335 | s21s34s39
4336 | s21s34s38
4337 | s21s29s122
4338 | s21s29s98
4339 | s21s29s97
4340 | s21s29s63
4341 | s21s29s53
4342 | s21s29s39
4343 | s21s29s38
4344 | s21s27
4345 | s21s27s98
4346 | s21s27s39
4347 | s21s27s28
4348 | s21s25
4349 | s21s24
4350 | s20s124
4351 | s20s115s122
4352 | s20s114s122
4353 | s20s113s122
4354 | s20s113s114s122
4355 | s20s98s115
4356 | s20s98s114
4357 | s20s98s113
4358 | s20s98s113s114
4359 | s20s97s115
4360 | s20s97s114
4361 | s20s97s113
4362 | s20s97s113s114
4363 | s20s93
4364 | s20s91
4365 | s20s90
4366 | s20s89
4367 | s20s89s90
4368 | s20s88s122
4369 | s20s88s98
4370 | s20s88s97
4371 | s20s88s89
4372 | s20s84s85
4373 | s20s80
4374 | s20s78
4375 | s20s78s79
4376 | s20s73
4377 | s20s73s122
4378 | s20s73s98
4379 | s20s73s97
4380 | s20s73s79s122
4381 | s20s73s79s98
4382 | s20s73s79s97
4383 | s20s73s77s78s122
4384 | s20s73s77s78s98
4385 | s20s73s77s78s97
4386 | s20s71s72
4387 | s20s71s72s122
4388 | s20s71s72s98
4389 | s20s71s72s97
4390 | s20s71s72s79s122
4391 | s20s71s72s79s98
4392 | s20s71s72s79s97
4393 | s20s71s72s77s78s122
4394 | s20s71s72s77s78s98
4395 | s20s71s72s77s78s97
4396 | s20s68
4397 | s20s66
4398 | s20s65s122
4399 | s20s65s98
4400 | s20s65s97
4401 | s20s64
4402 | s20s64s65
4403 | s20s63
4404 | s20s63s115
4405 | s20s63s114
4406 | s20s63s113
4407 | s20s63s113s114
4408 | s20s63s88
4409 | s20s63s73
4410 | s20s63s73s79
4411 | s20s63s73s77s78
4412 | s20s63s71s72
4413 | s20s63s71s72s79
4414 | s20s63s71s72s77s78
4415 | s20s63s65
4416 | s20s63s64s122
4417 | s20s63s64s98
4418 | s20s63s64s97
4419 | s20s59
4420 | s20s56s122
4421 | s20s56s98
4422 | s20s56s97
4423 | s20s56s63
4424 | s20s55
4425 | s20s55s122
4426 | s20s55s113s122
4427 | s20s55s98
4428 | s20s55s98s113
4429 | s20s55s97
4430 | s20s55s97s113
4431 | s20s55s63
4432 | s20s55s63s113
4433 | s20s54s114s122
4434 | s20s54s98s114
4435 | s20s54s97s114
4436 | s20s54s63s114
4437 | s20s54s55s122
4438 | s20s54s55s98
4439 | s20s54s55s97
4440 | s20s54s55s63
4441 | s20s53
4442 | s20s53s115
4443 | s20s53s114
4444 | s20s53s113
4445 | s20s53s113s114
4446 | s20s53s88
4447 | s20s53s73
4448 | s20s53s73s79
4449 | s20s53s73s77s78
4450 | s20s53s71s72
4451 | s20s53s71s72s79
4452 | s20s53s71s72s77s78
4453 | s20s53s65
4454 | s20s53s63s64
4455 | s20s53s56
4456 | s20s53s55
4457 | s20s53s55s113
4458 | s20s53s54s114
4459 | s20s53s54s55
4460 | s20s52s73s122
4461 | s20s52s73s98
4462 | s20s52s73s97
4463 | s20s52s71s72s122
4464 | s20s52s71s72s98
4465 | s20s52s71s72s97
4466 | s20s52s63s73
4467 | s20s52s63s71s72
4468 | s20s52s53
4469 | s20s52s53s122
4470 | s20s52s53s98
4471 | s20s52s53s97
4472 | s20s52s53s73
4473 | s20s52s53s71s72
4474 | s20s52s53s63
4475 | s20s47
4476 | s20s46
4477 | s20s46s122
4478 | s20s46s98
4479 | s20s46s97
4480 | s20s46s79s122
4481 | s20s46s79s98
4482 | s20s46s79s97
4483 | s20s46s77s78s122
4484 | s20s46s77s78s98
4485 | s20s46s77s78s97
4486 | s20s46s63
4487 | s20s46s63s79
4488 | s20s46s63s77s78
4489 | s20s46s53
4490 | s20s46s53s79
4491 | s20s46s53s77s78
4492 | s20s46s52s122
4493 | s20s46s52s98
4494 | s20s46s52s97
4495 | s20s46s52s63
4496 | s20s46s52s53
4497 | s20s45s46
4498 | s20s39
4499 | s20s39s115
4500 | s20s39s114
4501 | s20s39s113
4502 | s20s39s113s114
4503 | s20s39s88
4504 | s20s39s73
4505 | s20s39s73s79
4506 | s20s39s73s77s78
4507 | s20s39s71s72
4508 | s20s39s71s72s79
4509 | s20s39s71s72s77s78
4510 | s20s39s65
4511 | s20s39s63s64
4512 | s20s39s56
4513 | s20s39s55
4514 | s20s39s55s113
4515 | s20s39s54s114
4516 | s20s39s54s55
4517 | s20s39s52s73
4518 | s20s39s52s71s72
4519 | s20s39s52s53
4520 | s20s39s46
4521 | s20s39s46s79
4522 | s20s39s46s77s78
4523 | s20s39s46s52
4524 | s20s38s122
4525 | s20s38s115
4526 | s20s38s114
4527 | s20s38s113
4528 | s20s38s113s114
4529 | s20s38s98
4530 | s20s38s97
4531 | s20s38s88
4532 | s20s38s73
4533 | s20s38s73s79
4534 | s20s38s73s77s78
4535 | s20s38s71s72
4536 | s20s38s71s72s79
4537 | s20s38s71s72s77s78
4538 | s20s38s65
4539 | s20s38s63
4540 | s20s38s63s64
4541 | s20s38s56
4542 | s20s38s55
4543 | s20s38s55s113
4544 | s20s38s54s114
4545 | s20s38s54s55
4546 | s20s38s53
4547 | s20s38s52s73
4548 | s20s38s52s71s72
4549 | s20s38s52s53
4550 | s20s38s46
4551 | s20s38s46s79
4552 | s20s38s46s77s78
4553 | s20s38s46s52
4554 | s20s38s39
4555 | s20s34
4556 | s20s30
4557 | s20s29s122
4558 | s20s29s98
4559 | s20s29s97
4560 | s20s29s63
4561 | s20s29s53
4562 | s20s29s39
4563 | s20s29s38
4564 | s20s27
4565 | s20s27s122
4566 | s20s27s98
4567 | s20s27s97
4568 | s20s27s63
4569 | s20s27s53
4570 | s20s27s39
4571 | s20s27s38
4572 | s20s26
4573 | s20s26s96
4574 | s20s26s37
4575 | s20s24
4576 | s19
4577 | s19s122
4578 | s19s98
4579 | s19s96
4580 | s19s73
4581 | s19s71s72
4582 | s19s63
4583 | s19s55
4584 | s19s53
4585 | s19s53s54
4586 | s19s46
4587 | s19s39
4588 | s19s37
4589 | s19s28
4590 | s18
4591 | s18s96
4592 | s18s91
4593 | s18s78
4594 | s18s76s77
4595 | s18s51
4596 | s18s37
4597 | s18s32
4598 | s18s22
4599 | s18s19
4600 | s18s19s122
4601 | s18s19s98
4602 | s18s19s97
4603 | s18s19s96
4604 | s18s19s63
4605 | s18s19s53
4606 | s18s19s39
4607 | s18s19s38
4608 | s18s19s37
4609 | s17
4610 | s17s78
4611 | s17s76s77
4612 | s17s51
4613 | s15s90
4614 | s15s88s89
4615 | s15s63
4616 | s15s55
4617 | s15s53s54
4618 | s15s28
4619 | s14s98
4620 | s14s39
4621 | s12
4622 | s12s91
4623 | s12s89
4624 | s12s32
4625 | s12s30
4626 | s12s22
4627 | s11
4628 | s11s99
4629 | s11s97
4630 | s11s96
4631 | s11s92
4632 | s11s92s98
4633 | s11s90s98
4634 | s11s90s91
4635 | s11s90s91s98
4636 | s11s88s89
4637 | s11s88s89s98
4638 | s11s79
4639 | s11s73
4640 | s11s71s72
4641 | s11s69
4642 | s11s67
4643 | s11s67s98
4644 | s11s66s98
4645 | s11s65
4646 | s11s65s98
4647 | s11s65s66
4648 | s11s65s66s98
4649 | s11s64s65s98
4650 | s11s63
4651 | s11s63s98
4652 | s11s54
4653 | s11s54s98
4654 | s11s52s53
4655 | s11s52s53s98
4656 | s11s46
4657 | s11s40s98
4658 | s11s39
4659 | s11s39s98
4660 | s11s39s92
4661 | s11s39s90
4662 | s11s39s90s91
4663 | s11s39s88s89
4664 | s11s39s67
4665 | s11s39s66
4666 | s11s39s65
4667 | s11s39s65s66
4668 | s11s39s64s65
4669 | s11s39s63
4670 | s11s39s54
4671 | s11s39s52s53
4672 | s11s39s40
4673 | s11s38
4674 | s11s37
4675 | s11s31
4676 | s11s27
4677 | s11s27s98
4678 | s11s27s39
4679 | s10
4680 | s10s96
4681 | s10s89
4682 | s10s87
4683 | s10s73
4684 | s10s71s72
4685 | s10s68
4686 | s10s68s96
4687 | s10s55
4688 | s10s54
4689 | s10s53s54
4690 | s10s52s53
4691 | s10s46
4692 | s10s37
4693 | s10s37s68
4694 | s10s30
4695 | s10s27
4696 | s10s11
4697 | s9
4698 | s9s125
4699 | s9s124
4700 | s9s122
4701 | s9s120
4702 | s9s115
4703 | s9s114
4704 | s9s113
4705 | s9s113s114
4706 | s9s99
4707 | s9s92
4708 | s9s92s98
4709 | s9s90s91
4710 | s9s90s91s98
4711 | s9s88
4712 | s9s81
4713 | s9s79
4714 | s9s79s80
4715 | s9s69s96
4716 | s9s67s98
4717 | s9s66
4718 | s9s66s98
4719 | s9s65
4720 | s9s65s98
4721 | s9s65s66s98
4722 | s9s64s65s98
4723 | s9s63
4724 | s9s63s64
4725 | s9s61
4726 | s9s55s113
4727 | s9s54s114
4728 | s9s54s55
4729 | s9s53
4730 | s9s51
4731 | s9s40
4732 | s9s40s98
4733 | s9s39
4734 | s9s39s98
4735 | s9s39s92
4736 | s9s39s90s91
4737 | s9s39s67
4738 | s9s39s66
4739 | s9s39s65
4740 | s9s39s65s66
4741 | s9s39s64s65
4742 | s9s39s40
4743 | s9s38
4744 | s9s37s69
4745 | s9s29
4746 | s9s10
4747 | s9s10s96
4748 | s9s10s37
4749 | s8
4750 | s8s98
4751 | s8s96
4752 | s8s91
4753 | s8s78
4754 | s8s76s77
4755 | s8s66
4756 | s8s66s98
4757 | s8s64s65
4758 | s8s64s65s98
4759 | s8s51
4760 | s8s39
4761 | s8s39s98
4762 | s8s39s66
4763 | s8s39s64s65
4764 | s8s37
4765 | s8s32
4766 | s8s22
4767 | s7s78
4768 | s7s76s77
4769 | s7s51
4770 | s6s73
4771 | s6s71s72
4772 | s6s46
4773 | s5
4774 | s5s73
4775 | s5s71s72
4776 | s5s46
4777 | s4
4778 | s2s90
4779 | s2s67
4780 | s2s65s66
4781 | s2s40
4782 | s2s31
4783 | s2s21
4784 | s2s3
4785 | s1
4786 | s1s122
4787 | s1s98
4788 | s1s97
4789 | s1s63
4790 | s1s53
4791 | s1s39
4792 | s1s38
4793 | s0
4794 | 


--------------------------------------------------------------------------------