var src = `1.08.1966	5 7 8 15 22 23 27 34 37 39 40 41 43 44 50 55 57 58 62 70
2.08.1966	3 5 9 12 15 16 19 20 23 25 29 30 34 37 43 48 55 58 59 61
3.08.1966	2 3 5 12 15 21 23 24 26 28 36 37 38 39 50 53 55 59 66 68
4.08.1966	2 3 5 7 8 11 14 16 19 25 35 43 50 51 55 60 61 66 67 70
5.08.1966	2 8 11 12 14 17 18 20 21 28 36 43 50 53 55 56 59 62 64 66
6.08.1966	2 5 10 11 15 16 18 19 27 29 30 32 33 35 42 43 45 62 63 65
7.08.1966	5 6 7 8 16 21 27 30 39 46 49 50 51 53 54 58 62 64 68 70
8.08.1966	1 2 3 7 9 11 12 13 15 17 20 24 26 28 34 45 48 49 61 66
9.08.1966	7 8 12 13 14 21 23 24 27 28 30 38 40 49 50 52 53 54 63 68
10.08.1966	1 3 5 7 9 10 14 21 23 27 31 34 45 46 47 48 51 52 64 65
11.08.1966	1 5 6 7 9 11 14 17 29 30 33 36 37 39 42 43 48 50 64 65
12.08.1966	2 9 11 12 13 17 18 23 25 27 33 38 40 44 45 46 47 52 64 66
13.08.1966	1 5 6 11 14 16 17 20 22 23 25 26 31 41 44 47 56 59 64 70
14.08.1966	3 5 9 19 24 25 26 27 28 33 34 40 45 50 53 55 59 63 64 66
15.08.1966	3 6 8 11 13 19 23 25 28 32 33 34 37 41 50 54 56 57 59 65
16.08.1966	2 3 5 7 15 23 28 29 32 37 38 46 49 50 52 53 59 60 61 62
17.08.1966	1 5 7 9 11 16 18 20 22 25 26 35 45 46 47 51 56 67 68 70
18.08.1966	11 15 16 22 25 28 29 32 34 35 42 43 47 49 52 53 54 57 62 63
19.08.1966	8 9 15 17 26 30 31 35 37 38 41 42 44 50 52 58 60 64 66 69
20.08.1966	4 6 8 15 16 17 18 24 26 33 34 35 36 37 42 44 50 54 65 69
21.08.1966	5 7 8 15 22 23 27 34 37 39 40 42 44 45 46 47 52 64 66 69
22.08.1966	5 7 8 15 22 23 27 34 37 39 40 71 72 73 74 75 76 77 78 79`

var bitCount = function(n) { //со стак оверфлоу
  n = n - ((n >> 1) & 0x55555555)
  n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
  return ((n + (n >> 4) & 0xF0F0F0F) * 0x1010101) >> 24
}

var BITS = 32;
var numToBit = [0] //место цифры в битсете
for (let i = 0; i < BITS; i++) numToBit[i + 1] = 1 << i;

var data = src.split("\n").map(v=>{ //парсим исходные
    var [date, digs] = v.split("\t");
    digs = digs.split(" ").map(v=>+v); //кастим строки в числа
    var bits = [0, 0, 0, 0, 0, 0, 0, 0]; //По 4 байта на число, 32 цифры в числе. Их 8, шоб всем хватило 
    //(хватает и 3-х, самая большая цифра - 256. Надо больше, сделай больше)
    digs.forEach(v=>{
        var shift = Math.floor((v - 1) / BITS); //элемент массива bits
        bits[shift] = bits[shift] | numToBit[v - shift * BITS] //"Сдвигаем" число
    });
    return {date, digs, bits}
});

var res = [];

for (let i = 0; i < data.length - 1; i++) {
    for (let j = i + 1; j < data.length; j++) { //перебор всех со всеми
        var v1 = data[i], v2 = data[j];
        var hits = 0;
        var join = [];
        for (let b = 0; b < 8; b++) {
            var cross = v1.bits[b] & v2.bits[b];
            numToBit.forEach((v,dig)=>{
                if (v & cross) join.push(dig + b * BITS);
            });
            //hits += bitCount(cross); //считаем совпавшие биты (цифры)
        }
        if (join.length >= 10) {
            res.push({set1 : v1, set2 : v2, join, hits : join.length}); // заполняем массив нужным
        }
    }
}

//Комбинаторный итератор
var iterator = function(size, digs = 9) {
    var pos = []
    var inc = function() {
        if (this.n <= 0 && this.next) {
            this.n = this.next.n + 1;
        } else {
            this.n++;
        }
        if (this.n > digs) {
            if (!this.next) return this.n = null;
            var nInc = this.next.inc();
            if (nInc) {
                this.n = -1;
            } else {
                return this.n = null;
            }
            if (this.n > digs) this.inc(); 
        }
        return this.n;
    }
    for (let i = 0; i < size; i++) pos[i] = {n : 0, inc};
    for (let i = 0; i < size; i++) {
        var rec = pos[i];
        if (i == 0) rec.first = true;
        if (i == size - 1) rec.last = true;
        if (!(rec.fisrt && rec.last)) {
            if (!rec.last) rec.next = pos[i+1];
            if (!rec.first) rec.prev = pos[i-1]
        }
    }
    return { 
        first : pos[0], 
        get : (n)=>pos[n].n,
        inc : ()=>pos[0].inc(),
        map : ()=>pos.map(v=>v.n),
        pos
    }
}

//Комбинитрует массив размером > 10
var combine = function(arr) {
    var c = arr.length
    if (c < 10) return false;
    if (c == 10) return [arr];
    var n = c - 10;
    var base = arr.slice(0,10);
    var ext = arr.slice(10);
    var it = iterator(n);
    var ret = [base];
    do {
        var rec = [...base];
        it.map().forEach((v,i)=>{if (v >= 0) rec[v] = ext[i]});
        ret.push(rec);
    } while (it.inc() != null);
    return ret; 
}


//Выхлоп
var out = []

res.forEach(v=>{
    out.push(...combine(v.join).map(j=>[j.join(" "), v.set1.date, v.set2.date, v.hits].join(",")));
});

fs.writeFileSync("out.txt", out.join("\n"))

var iterator = function(size, digs = 9) {
    var pos = []
    var inc = function() {
        if (this.n <= 0 && this.next && this.next.n > 0) {
            this.n = this.next.n + 1;
        } else {
            this.n++;
        }
        if (this.next && this.n == this.next.n) return this.inc()
        if (this.n > digs) {
            if (!this.next) return this.n = null;
            var nInc = this.next.inc();
            if (nInc != null) {
                this.n = -1;
            } else {
                return this.n = null;
            }
            if (this.n > digs) this.inc(); 
        }
        return this.n;
    }
    for (let i = 0; i < size; i++) pos[i] = {n : -1, inc};
    for (let i = 0; i < size; i++) {
        var rec = pos[i];
        if (i == 0) rec.first = true;
        if (i == size - 1) rec.last = true;
        if (!(rec.fisrt && rec.last)) {
            if (!rec.last) rec.next = pos[i+1];
            if (!rec.first) rec.prev = pos[i-1]
        }
    }
    return { 
        first : pos[0], 
        get : (n)=>pos[n].n,
        inc : ()=>pos[0].inc(),
        map : ()=>pos.map(v=>v.n),
        pos
    }
}