#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <string>
#include <sstream>

using namespace std;

void print_vector(const vector<int>& vec) {
    for (size_t i = 0; i < vec.size(); ++i) {
        cout << vec[i] << (i == vec.size() - 1 ? "" : " ");
    }
    cout << endl;
}

int main() {
    string line;
    getline(cin, line);
    if (line.empty()) {
        cout << "null" << endl;
        return 0;
    }
    
    stringstream ss(line);
    vector<int> ids;
    int num;
    while (ss >> num) {
        ids.push_back(num);
    }
    
    map<int, int> counts;
    for (int id : ids) {
        counts[id]++;
    }

    for (auto const& [id, count] : counts) {
        if (count > 2) {
            cout << "null" << endl;
            return 0;
        }
    }

    vector<int> group_a;
    vector<int> group_b;
    vector<int> singles;

    for (auto const& [id, count] : counts) {
        if (count == 2) {
            group_a.push_back(id);
            group_b.push_back(id);
        } else {
            singles.push_back(id);
        }
    }

    // singles 已经是按键（ID）排序的
    int num_singles_for_a = singles.size() / 2;
    for (int i = 0; i < num_singles_for_a; ++i) {
        group_a.push_back(singles[i]);
    }
    for (size_t i = num_singles_for_a; i < singles.size(); ++i) {
        group_b.push_back(singles[i]);
    }

    sort(group_a.begin(), group_a.end());
    sort(group_b.begin(), group_b.end());

    print_vector(group_a);
    print_vector(group_b);

    return 0;
}

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        
        if (line == null || line.trim().isEmpty()) {
            System.out.println("null");
            return;
        }

        String[] parts = line.split("\\s+");
        List<Integer> ids = new ArrayList<>();
        for (String part : parts) {
            ids.add(Integer.parseInt(part));
        }

        Map<Integer, Integer> counts = new HashMap<>();
        for (int id : ids) {
            counts.put(id, counts.getOrDefault(id, 0) + 1);
        }

        for (int count : counts.values()) {
            if (count > 2) {
                System.out.println("null");
                return;
            }
        }

        List<Integer> groupA = new ArrayList<>();
        List<Integer> groupB = new ArrayList<>();
        List<Integer> singles = new ArrayList<>();

        List<Integer> sortedKeys = new ArrayList<>(counts.keySet());
        Collections.sort(sortedKeys);

        for (int id : sortedKeys) {
            if (counts.get(id) == 2) {
                groupA.add(id);
                groupB.add(id);
            } else {
                singles.add(id);
            }
        }

        int numSinglesForA = singles.size() / 2;
        for (int i = 0; i < numSinglesForA; i++) {
            groupA.add(singles.get(i));
        }
        for (int i = numSinglesForA; i < singles.size(); i++) {
            groupB.add(singles.get(i));
        }

        Collections.sort(groupA);
        Collections.sort(groupB);

        System.out.println(groupA.stream().map(String::valueOf).collect(Collectors.joining(" ")));
        System.out.println(groupB.stream().map(String::valueOf).collect(Collectors.joining(" ")));
    }
}

from collections import Counter

def solve():
    line = input()
    if not line:
        print("null")
        return
        
    ids = list(map(int, line.split()))
    
    counts = Counter(ids)
    
    if any(count > 2 for count in counts.values()):
        print("null")
        return
        
    group_a = []
    group_b = []
    singles = []
    
    # 对ID进行排序以保证处理顺序，从而使singles列表自然有序
    for id_val in sorted(counts.keys()):
        if counts[id_val] == 2:
            group_a.append(id_val)
            group_b.append(id_val)
        else:
            singles.append(id_val)
            
    num_singles_for_a = len(singles) // 2
    
    group_a.extend(singles[:num_singles_for_a])
    group_b.extend(singles[num_singles_for_a:])
    
    group_a.sort()
    group_b.sort()
    
    print(*group_a)
    print(*group_b)

solve()