#include <bits/stdc++.h>  // 引入 C++ 标准库。

using namespace std;  // 使用 "std" 命名空间，表示使用标准库组件。

int main() {
    int n, m;
    cin >> n >> m;  // 从标准输入读取两个整数 n 和 m。

    vector<deque<int>> a(n);  // 创建一个二维数组 a，每个元素是一个 deque 容器，用于存储每个玩家的手牌。

    for (int i = 0; i < n; i++) {  // 针对每个玩家：
        int x;
        for (int j = 0; j < m / n; j++) {  // 读取该玩家的手牌，每个玩家的手牌数为 m/n。
            cin >> x;
            a[i].push_back(x);  // 将读取的牌添加到玩家 i 的手牌 deque 中。
        }
    }

    unordered_map<int, int> mp;  // 创建一个无序 map，用于存储每张牌在桌面上出现的次数。

    vector<int> s;  // 创建一个 vector，模拟桌面上的牌堆。

    int cnt = n;  // 初始化一个计数器，记录还剩下多少玩家。
    int r = 0;  // 初始化一个计数器，记录已经进行了多少轮游戏。

    while (cnt > 1) {  // 当还有多于一个玩家时：
        r++;  // 轮数加一。

        for (int i = 0; i < n; i++) {  // 针对每个玩家：
            if (a[i].empty()) {  // 如果该玩家的手牌已经出完：
                continue;  // 跳过该玩家。
            }

            int cur = a[i].front();  // 获取当前玩家的手牌的第一张牌。
            a[i].pop_front();  // 从玩家手牌中移除该牌。

            if (mp[cur] > 0) {  // 如果这张牌在桌面上已经出现过：
                vector<int> s1 = {cur};  // 初始化一个列表，用于存储需要拿走的牌。

                while (s.back() != cur) {  // 当模拟桌面上的最后一张牌不是当前牌时：
                    s1.push_back(s.back());  // 将模拟桌面上的最后一张牌添加到列表 s1 中。
                    mp[s.back()]--;  // 减少该牌在桌面上出现的次数。
                    s.pop_back();  // 从模拟桌面上移除该牌。
                }

                s1.push_back(s.back());  // 将模拟桌面上的最后一张牌（即当前牌）添加到列表 s1 中。
                s.pop_back();  // 从模拟桌面上移除当前牌。
                mp[s1.back()]--;  // 减少当前牌在桌面上出现的次数。

                for (int &x : s1) {  // 针对列表 s1 中的每张牌：
                    a[i].push_back(x);  // 将牌添加回玩家 i 的手牌中。
                }
            } else {  // 如果这张牌在桌面上未出现过：
                s.push_back(cur);  // 将这张牌添加到桌面上。
                mp[cur]++;  // 增加该牌在桌面上出现的次数。

                if (a[i].empty()) {  // 如果玩家 i 的手牌已经出完：
                    cnt--;  // 减少剩余的玩家数量。
                    if (cnt == 1) {  // 如果只剩下一个玩家：
                        break;  // 退出循环。
                    }
                }
            }
        }
    }

    int pos = -1;  // 初始化一个变量，用于记录最后一个出局的玩家的位置。

    for (int i = 0; i < n; i++) {  // 针对每个玩家：
        if (!a[i].empty()) {  // 如果该玩家的手牌还未出完：
            pos = i;  // 记录该玩家的位置。
            break;
        }
    }

    cout << r << endl;  // 输出已经进行的轮数。
    cout << pos + 1 << endl;  // 输出最后一个出局的玩家的位置（由于玩家的编号从 1 开始，所以需要加一）。

    while (!a[pos].empty()) {  // 当最后一个出局的玩家的手牌不为空时：
        cout << a[pos].front() <<" "; 
        a[pos].pop_front();
    }
    return 0;
}

import java.util.*;  // 导入 Java 标准工具包的所有内容，包括 Scanner、List、Deque、Map、ArrayList、LinkedList 和 HashMap 等。

public class Main {  // 定义名为 Main 的公共类。
    public static void main(String[] args) {  // 主函数，程序的入口。
        Scanner scanner = new Scanner(System.in);  // 创建一个新的 Scanner 对象，用于从标准输入读取用户输入的内容。
        int n = scanner.nextInt();  // 读取输入中的整数并存储在变量 n 中。
        int m = scanner.nextInt();  // 读取输入中的整数并存储在变量 m 中。

        List<Deque<Integer>> a = new ArrayList<>();  // 创建一个空的列表，用于存储每个玩家的手牌，列表中的每个元素都是一个双端队列。
        for (int i = 0; i < n; i++) {  // 针对每个玩家：
            Deque<Integer> playerHand = new LinkedList<>();  // 创建一个新的双端队列，用于存储当前玩家的手牌。
            for (int j = 0; j < m / n; j++) {  // 针对每个玩家的每张手牌：
                int x = scanner.nextInt();  // 从标准输入读取整数并将其存储在变量 x 中。
                playerHand.add(x);  // 将读取的整数添加到当前玩家的手牌中。
            }
            a.add(playerHand);  // 将当前玩家的手牌添加到列表 a 中。
        }

        Map<Integer, Integer> mp = new HashMap<>();  // 创建一个空的 HashMap 对象，用于存储每张牌在桌面上出现的次数。
        List<Integer> s = new ArrayList<>();  // 创建一个空的列表，用于模拟桌面上的牌堆。
        int cnt = n;  // 初始化一个计数器，用于记录还剩下多少玩家。
        int r = 0;  // 初始化一个计数器，用于记录已经进行了多少轮游戏。

        while (cnt > 1) {  // 当仍然有多于一个玩家时，执行循环。
            r++;  // 每次循环轮数加一。
            for (int i = 0; i < n; i++) {  // 针对每个玩家执行循环：
                if (a.get(i).isEmpty()) {  // 如果当前玩家手中没有牌，则跳过该玩家。
                    continue;
                }
                int cur = a.get(i).poll();  // 从当前玩家的手牌中移除并返回第一张牌。
                if (mp.getOrDefault(cur, 0) > 0) {  // 如果桌面上已经有与当前牌相同的牌，则执行下面的操作。
                    List<Integer> s1 = new ArrayList<>();  // 创建一个空的列表，用于存储需要拿走的牌。
                    s1.add(cur);  // 将当前牌添加到列表 s1 中。
                    while (!s.isEmpty() && !s.get(s.size() - 1).equals(cur)) {  // 当桌面上最后一张牌不是当前牌时，执行循环。
                        s1.add(s.remove(s.size() - 1));  // 将桌面上的最后一张牌添加到列表 s1 中，并从列表 s 中移除。
                        mp.put(s1.get(s1.size() - 1), mp.get(s1.get(s1.size() - 1)) - 1);  // 桌面上最后一张牌出现次数减一。
                    }
                    s1.add(s.remove(s.size() - 1));  // 将桌面上的最后一张牌添加到列表 s1 中，并从列表 s 中移除。
                    mp.put(s1.get(s1.size() - 1), mp.get(s1.get(s1.size() - 1)) - 1);  // 桌面上最后一张牌出现次数减一。
                    a.get(i).addAll(s1);  // 将列表 s1 中的牌添加回当前玩家的手牌中。
                } else {  // 如果桌面上没有与当前牌相同的牌，则执行下面的操作。
                    s.add(cur);  // 将当前牌添加到桌面上。
                    mp.put(cur, mp.getOrDefault(cur, 0) + 1);  // 增加当前牌在桌面上出现的次数。
                    if (a.get(i).isEmpty()) {  // 如果当前玩家的手牌已经出完，则执行下面的操作。
                        cnt--;  // 减少剩余的玩家数量。
                        if (cnt == 1) {  // 如果只剩下一个玩家，则退出循环。
                            break;
                        }
                    }
                }
            }
        }

        int pos = -1;  // 初始化一个变量，用于记录最后一个出局的玩家的位置。
        for (int i = 0; i < n; i++) {  // 针对每个玩家执行循环：
            if (!a.get(i).isEmpty()) {  // 如果当前玩家的手牌还未出完，则执行下面的操作。
                pos = i;  // 记录当前玩家的位置。
                break;
            }
        }

        System.out.println(r);  // 输出已经进行的轮数。
        System.out.println(pos + 1);  // 输出最后一个出局的玩家的位置（由于玩家的编号从 1 开始，所以需要加一）。

        StringBuilder output = new StringBuilder();
        while (!a.get(pos).isEmpty()) {  // 当最后一个出局的玩家的手牌不为空时，执行循环。
            output.append(a.get(pos).peek()).append(" ");  // 将当前玩家手牌的第一张牌添加到输出中。
            a.get(pos).poll();  // 从当前玩家的手牌中移除第一张牌。
        }
        System.out.println(output.toString().trim());  // 输出最后一个出局的玩家的手牌。
    }
}

from collections import defaultdict  # 导入 defaultdict，它是内置 dict 类的子类，它重写了一个方法并添加了一个可写的实例变量。其余的功能与 dict 类相同。

n = int(input())  # 读取玩家的数量
m = int(input())  # 读取牌的数量

a = []  # 初始化一个空列表，用于存储每个玩家的手牌
for _ in range(n):  # 对于每个玩家
	a.append(list(map(int , input().split())))  # 读取该玩家的手牌，并将其添加到列表 a 中

s = []  # 初始化一个空列表，用于存储桌面上的牌
mp = defaultdict(int)  # 初始化一个默认字典，用于存储每张牌在桌面上出现的次数

cnt = n  # 初始化一个计数器，用于记录还剩下多少玩家
r = 0  # 初始化一个计数器，用于记录已经进行了多少轮

while cnt > 1:  # 当还有多于一个玩家时
	r += 1  # 轮数加一
	for i in range(n):  # 对于每个玩家
		if not a[i]:  # 如果该玩家的手牌已经出完
			continue  # 则跳过该玩家
		now = a[i].pop(0)  # 否则，该玩家打出他的第一张牌
		if mp[now] != 0:  # 如果这张牌与桌面上的某张牌相同
			seq = [now]  # 则初始化一个列表，用于存储需要拿走的牌
			while s[-1] != now:  # 当列表 s 的最后一张牌不是当前牌时
				seq.append(s.pop())  # 将列表 s 的最后一张牌添加到列表 seq 中，并从列表 s 中移除
				mp[seq[-1]] -= 1  # 将这张牌在桌面上的出现次数减一
			seq.append(s.pop())  # 将列表 s 的最后一张牌（即当前牌）添加到列表 seq 中，并从列表 s 中移除
			mp[seq[-1]] -= 1  # 将当前牌在桌面上的出现次数减一
			a[i] += seq  # 将列表 seq 中的牌添加到玩家 i 的手牌中
		else:  # 如果这张牌与桌面上的所有牌都不相同
			s.append(now)  # 则将这张牌添加到桌面上
			mp[now] += 1  # 并将这张牌在桌面上的出现次数加一
		
		if not a[i]:  # 如果玩家 i 的手牌已经出完
			cnt -= 1  # 则剩余的玩家数量减一
			if cnt == 1:  # 如果只剩下一个玩家
				break  # 则跳出循环

pos = -1  # 初始化一个变量，用于记录最后一个出局的玩家的位置
for i in range(n):  # 对于每个玩家
	if a[i]:  # 如果该玩家还未出局
		pos = i  # 则记录该玩家的位置

print(r)  # 输出已经进行的轮数
print(pos + 1)  # 输出最后一个出局的玩家的位置（由于玩家的编号从 1 开始，所以需要加一）
print(" ".join(map(str , a[pos])))  # 输出最后一个出局的玩家的手牌