#include <bits/stdc++.h>
using namespace std;

static void backtrack(const vector<int>& nums, int start, int target, vector<int>& path, vector<vector<int>>& res){
    if(target==0){
        res.push_back(path);
        return;
    }
    for(int i=start;i<(int)nums.size();++i){
        if(i>start && nums[i]==nums[i-1]) continue; // skip duplicates
        if(nums[i]>target) break; // pruning
        path.push_back(nums[i]);
        backtrack(nums,i+1,target-nums[i],path,res);
        path.pop_back();
    }
}

vector<vector<int>> combinationSum2(vector<int>& nums, int target){
    sort(nums.begin(), nums.end());
    vector<vector<int>> res;
    vector<int> path;
    backtrack(nums,0,target,path,res);
    return res;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; if(!(cin>>n)) return 0;
    vector<int> nums(n);
    for(int i=0;i<n;++i) cin>>nums[i];
    int target; cin>>target;
    auto ans = combinationSum2(nums,target);
    for(const auto& comb:ans){
        for(size_t i=0;i<comb.size();++i){
            if(i) cout<<' ';
            cout<<comb[i];
        }
        cout<<"\n";
    }
    return 0;
}

import java.util.*;

public class Main {
    public static List<List<Integer>> combinationSum2(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        backtrack(nums, 0, target, path, res);
        return res;
    }

    private static void backtrack(int[] nums, int start, int remain, List<Integer> path, List<List<Integer>> res) {
        if (remain == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = start; i < nums.length; i++) {
            if (i > start && nums[i] == nums[i - 1]) continue; // skip duplicates
            if (nums[i] > remain) break;
            path.add(nums[i]);
            backtrack(nums, i + 1, remain - nums[i], path, res);
            path.remove(path.size() - 1);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        if (!sc.hasNextInt()) return;
        int n = sc.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) nums[i] = sc.nextInt();
        int target = sc.nextInt();
        List<List<Integer>> ans = combinationSum2(nums, target);
        for (List<Integer> comb : ans) {
            for (int i = 0; i < comb.size(); i++) {
                if (i > 0) System.out.print(" ");
                System.out.print(comb.get(i));
            }
            System.out.println();
        }
    }
}

def combination_sum2(nums, target):
    nums.sort()
    res=[]
    path=[]
    def backtrack(start, remain):
        if remain==0:
            res.append(path.copy())
            return
        for i in range(start, len(nums)):
            if i>start and nums[i]==nums[i-1]:
                continue
            if nums[i]>remain:
                break
            path.append(nums[i])
            backtrack(i+1, remain-nums[i])
            path.pop()
    backtrack(0, target)
    return res

if __name__=="__main__":
    import sys
    data=sys.stdin.read().strip().split()
    if not data:
        sys.exit(0)
    n=int(data[0])
    nums=list(map(int, data[1:1+n]))
    target=int(data[1+n])
    ans=combination_sum2(nums,target)
    for comb in ans:
        print(' '.join(map(str,comb)))

function combinationSum2(nums, target) {
    nums.sort((a,b)=>a-b);
    const res=[];
    const path=[];
    function backtrack(start, remain){
        if(remain===0){
            res.push([...path]);
            return;
        }
        for(let i=start;i<nums.length;i++){
            if(i>start && nums[i]===nums[i-1]) continue; // skip dup
            if(nums[i]>remain) break;
            path.push(nums[i]);
            backtrack(i+1, remain-nums[i]);
            path.pop();
        }
    }
    backtrack(0,target);
    return res;
}

// Driver (same as template)
const readline = require('readline');
const rl = readline.createInterface({input:process.stdin,output:process.stdout});
let lines=[];
rl.on('line', line=>{lines.push(line.trim()); if(lines.length===3) rl.close();});
rl.on('close',()=>{
    const n = parseInt(lines[0]);
    const nums = lines[1].split(/\s+/).map(Number);
    const target = parseInt(lines[2]);
    const res = combinationSum2(nums,target);
    res.forEach(comb=> console.log(comb.join(' ')));
});