#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
#pragma GCC optimize("Ofast","unroll-loops","inline","no-stack-protector")
#include <bits/stdc++.h>
using namespace std;
namespace Def{
    #define fir first
    #define sec second
    #define lson (tr[i].ls)
    #define rson (tr[i].rs)
    #define FIO(file) freopen(file".in","r",stdin), freopen(file".out","w",stdout)
    #define Untie() ios::sync_with_stdio(0), cin.tie(0),cout.tie(0)
    typedef long long ll;
    typedef double db;
    typedef long double ldb;
    typedef unsigned int uint;
    typedef unsigned long long ull;
    typedef pair<int,int> pii;
    typedef pair<ll,ll> pll;
    typedef __int128_t i128;
}
using namespace Def;
namespace FastIO {
	struct IO {
	    char ibuf[(1 << 20) + 1], *iS, *iT, obuf[(1 << 20) + 1], *oS;
	    IO() : iS(ibuf), iT(ibuf), oS(obuf) {} ~IO() { fwrite(obuf, 1, oS - obuf, stdout); }
		#if ONLINE_JUDGE
		#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, (1 << 20) + 1, stdin), (iS == iT ? EOF : *iS++) : *iS++)
		#else
		#define gh() getchar()
		#endif
		inline bool eof (const char &ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == 't' || ch == EOF; }
	    inline long long read() {
	        char ch = gh();
	        long long x = 0;
	        bool t = 0;
	        while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
	        while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gh();
	        return t ? ~(x - 1) : x;
	    }
	    inline void read (char *s) {
	    	char ch = gh(); int l = 0;
	    	while (eof(ch)) ch = gh();
	    	while (!eof(ch)) s[l++] = ch, ch = gh();
	    }
	    inline void read (double &x) {
	    	char ch = gh(); bool t = 0;
	    	while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
	    	while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = gh();
	    	if (ch != '.') return t && (x = -x), void(); ch = gh();
	    	for (double cf = 0.1; '0' <= ch && ch <= '9'; ch = gh(), cf *= 0.1) x += cf * (ch ^ 48);
	    	t && (x = -x);
	    }
	    inline void pc (char ch) {
	    	#ifdef ONLINE_JUDGE
	    	if (oS == obuf + (1 << 20) + 1) fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; 
	    	*oS++ = ch;
	    	#else
	    	putchar(ch);
	    	#endif
		}
        inline void write (char *s)
        {
            int len = strlen(s);
            for(int i = 0; i < len; i++)pc(s[i]);
        }
		template<typename _Tp>
	    inline void write (_Tp x) {
	    	static char stk[64], *tp = stk;
	    	if (x < 0) x = ~(x - 1), pc('-');
			do *tp++ = x % 10, x /= 10;
			while (x);
			while (tp != stk) pc((*--tp) | 48);
	    }
	    inline void puts(const char *s){
			int len = strlen(s);
			for (int i = 0; i < len; i++)pc(s[i]);
		}
	} io;
	inline long long read () { return io.read(); }
	template<typename Tp>
	inline void read (Tp &x) { io.read(x); }
	template<typename _Tp>
	inline void write (_Tp x) { io.write(x); }
}
using namespace FastIO;
namespace misc{
    constexpr int infi=1e9;
    constexpr int minfi=0x3f3f3f3f;
    constexpr ll infl=1e18;
    constexpr ll minfl=0x3f3f3f3f3f3f3f3f;
    constexpr int mod=998244353;
    constexpr int inv2=(mod+1)/2;
    constexpr int inv3=(mod+1)/3;
    mt19937_64 rnd(0x3494393);
    template<typename T,typename E>
        inline T ksm(T b,E p){T ret=1;while(p){if(p&1)ret=1ll*ret*b%mod;b=1ll*b*b%mod;p>>=1;}return ret;}
    template<typename T,typename E> 
        inline T ginv(T v){return ksm(v,mod-2);}
    template<typename T,typename E>
        inline void cmax(T &a,E b){a<b?(a=b,1):0;}
    template<typename T,typename E>
        inline void cmin(T &a,E b){a>b?(a=b,1):0;}
    template<typename T,typename E>
        inline void cadd(T &a,E b){(a+=b)>=mod?(a-=mod):0;}
    template<typename T,typename E>
        inline void csub(T &a,E b){(a-=b)<0?(a+=mod):0;}
    template<typename T,typename E>
        inline void cmul(T &a,E b){a=1ll*a*b%mod;}
    template<typename T,typename E>
        inline T madd(T a,E b){return (a+=b)>=mod?(a-mod):a;}
    template<typename T,typename E>
        inline T msub(T a,E b){return (a-=b)<0?(a+mod):a;}
    template<typename T,typename E>
        inline T mmul(T a,E b){return 1ll*a*b%mod;}
    template<typename T>
        struct dseg{T *first,*last;dseg(T* _l,T* _r):first(_l),last(_r){}};
    inline void debug(void){cerr<<'\n';}
    template<typename T,typename... arg>
        inline void debug(T x,arg... r){cerr<<x<<' ';debug(r...);}
    template<typename T,typename... arg>
        inline void debug(dseg<T> A,arg... v){cerr<<"[ ";for(T* i=A.first;i!=A.last;++i)cerr<<*i<<' ';cerr<<"] ";debug(v...);}
    template<typename T>
        inline T randseg(T l,T r){assert(l<=r);return rnd()%(r-l+1)+l;}
    template<typename T>
        inline bool gbit(T v,int bit){return v>>bit&1;}
    inline ll gcd(ll a,ll b){if(!b||!a) return a+b;ll az=__builtin_ctz(a),bz=__builtin_ctz(b),z=(az>bz)?bz:az,t;b>>=bz;while(a) a>>=az,t=a-b,az=__builtin_ctz(t),b=a<b?a:b,a=t<0?-t:t;return b<<z;}
    inline ll exgcd(ll a,ll b,ll &x,ll &y){if(!b){x=1,y=0;return a;}ll g=exgcd(b,a%b,y,x);y-=x*(a/b);return g;}
    inline ll Sum1(ll n){return n*(n+1)/2;}
    inline ll Sum2(ll n){return n*(n+1)*(2*n+1)/6;}
    inline ll Sqr(ll n){return n*n;}
    #define binom(n,m) (n<0||m<0||n<m?0:1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod)
    #define likely(x) (__builtin_expect(!!(x),1))
    #define unlikely(x) (__builtin_expect(!!(x),0))
}
using namespace misc;
#include <bits/stdc++.h>
using namespace std;

const double eps = 1e-8;
int sgn(double x) {
    if (fabs(x) < eps) {
        return 0;
    }
    return (x < 0) ? -1 : 1;
}

struct Point {
    double x, y;
    Point(double x = 0.0, double y = 0.0) : x(x), y(y) {}
};
typedef Point Vector;
const double pi = acos(-1.0);

Point operator - (Point A) {
    return Point(-A.x,-A.y); 
}
Vector operator + (Vector A, Vector B) {
    return Vector(A.x + B.x, A.y + B.y);
}
Vector operator - (Point A, Point B) {
    return Vector(A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p) {
    return Vector(A.x * p, A.y * p);
}
Vector operator / (Vector A, double p) {
    return Vector(A.x / p, A.y / p);
}
bool operator < (const Point A, const Point B) {
    return A.x < B.x || (sgn(A.x - B.x) == 0 && A.y < B.y);
}
bool operator == (const Point A, const Point B) {
    return sgn(A.x - B.x) == 0 && sgn(A.y - B.y) == 0;
}
double dot(Vector A, Vector B) {
    return A.x * B.x + A.y * B.y;
}
double cross(Vector A, Vector B) {
    return A.x * B.y - A.y * B.x;
}
double length(Vector A) {
    return sqrt(dot(A, A));
}
double length(Point A,Point B){
    return length(length(A-B));
}
double angle(Vector A, Vector B) {
    return acos(dot(A, B) / length(A) / length(B));
}
double areatri(Point A, Point B, Point C) {
    return fabs(cross(B - A, C - A)) / 2;
}
Vector rotate(Vector A, double rad) {
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
Vector normal(Vector A) {
    double L = length(A);
    return Vector(-A.y / L, A.x / L);
}
Point lineintersection(Point P, Vector v, Point Q, Vector w) {
    Vector u = P - Q;
    double t = cross(w, u) / cross(v, w);
    return P + v * t;
}
double linedistance(Point P, Point A, Point B) {
    Vector v1 = B - A, v2 = P - A;
    return fabs(cross(v1, v2)) / length(v1);
}
Point lineproject(Point P, Point A, Point B) {
    Vector v = B - A;
    return A + v * (dot(v, P - A) / dot(v, v));
}
double segdistance(Point P, Point A, Point B) {
    if (sgn(dot(P - A, B - A)) < 0) {
        return length(P - A);
    }
    if (sgn(dot(P - B, A - B)) < 0) {
        return length(P - B);
    }
    return fabs(cross(B - A, P - A)) / length(A - B);
}
bool segintersection(Point A, Point B, Point P, Point Q) {
    double c1 = cross(B - A, P - A), c2 = cross(B - A, Q - A);
    double c3 = cross(Q - P, A - P), c4 = cross(Q - P, B - P);
    return sgn(c1) * sgn(c2) < 0 && sgn(c3) * sgn(c4) < 0;
}
bool onseg(Point P, Point A, Point B) {
    return sgn(cross(A - P, B - P)) == 0 && sgn(dot(A - P, B - P)) < 0;
}
struct Circle {
    Point O;
    double r;
    Circle(Point O, double r): O(O), r(r) {}
    Point point(double a) {
        return Point(O.x + cos(a) * r, O.y + sin(a) * r);
    }
};
int linecirintersection(Circle C, Point A, Point B, vector<Point>& sol) {
    double a = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y);
    double b = 2 * (B.x - A.x) * (A.x - C.O.x) + 2 * (B.y - A.y) * (A.y - C.O.y);
    double c = (A.x - C.O.x) * (A.x - C.O.x) + (A.y - C.O.y) * (A.y - C.O.y) - C.r * C.r;
    double delta = b * b - 4 * a * c;
    if (sgn(delta) < 0) {
        return 0;
    }
    if (sgn(delta) == 0) {
        double t = -b / (2 * a);
        sol.push_back(A + (B - A) * t);
        return 1;
    }
    double t1 = (-b - sqrt(delta)) / (2 * a);
    double t2 = (-b + sqrt(delta)) / (2 * a);
    sol.push_back(A + (B - A) * t1);
    sol.push_back(A + (B - A) * t2);
    return 2;
}
double vecangle(Vector v) {
    return atan2(v.y, v.x);
}
int circirintersection(Circle C1, Circle C2, vector<Point>& sol) {
    double d = length(C1.O - C2.O);
    if (sgn(fabs(C1.r - C2.r) - d) > 0) {
        return 0;
    }
    if (sgn(C1.r + C2.r - d) < 0) {
        return 0;
    }
    double a = vecangle(C2.O - C1.O);
    double da = acos((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));
    if (sgn(da) == 0) {
        sol.push_back(C1.point(a));
        return 1;
    }
    sol.push_back(C1.point(a - da));
    sol.push_back(C1.point(a + da));
    return 2;
}
int gettans(Point P, Circle C, vector<Vector>& v) {
    Vector u = C.O - P;
    double d = length(u);
    if (sgn(d - C.r) < 0) {
        return 0;
    }
    if (sgn(d - C.r) == 0) {
        v.push_back(rotate(u, pi / 2));
        return 1;
    }
    double ang = asin(C.r / d);
    v.push_back(rotate(u, -ang));
    v.push_back(rotate(u, ang));
    return 2;
}
int getcirtans(Circle C1, Circle C2, vector<Point>& v1, vector<Point>& v2) {
    if (C1.r < C2.r) {
        swap(C1, C2);
        swap(v1, v2);
    }
    double d = length(C1.O - C2.O);
    double rd = C1.r - C2.r;
    double rsum = C1.r + C2.r;
    if (sgn(d - rd) < 0) {
        return 0;
    }
    if (sgn(d) == 0 && sgn(C1.r - C2.r) == 0) {
        return -1;
    }
    double base = vecangle(C2.O - C1.O);
    if (sgn(d - rd) == 0) {
        v1.push_back(C1.point(base));
        v2.push_back(C2.point(base));
        return 1;
    }
    double ang = acos(rd / d);
    v1.push_back(C1.point(base + ang));
    v2.push_back(C2.point(base + ang));
    v1.push_back(C1.point(base - ang));
    v2.push_back(C2.point(base - ang));
    if (sgn(d - rsum) < 0) {
        return 2;
    }
    if (sgn(d - rsum) == 0) {
        v1.push_back(C1.point(base));
        v2.push_back(C2.point(pi + base));
        return 3;
    }
    ang = acos(rsum / d);
    v1.push_back(C1.point(base + ang));
    v2.push_back(C2.point(pi + base + ang));
    v1.push_back(C1.point(base - ang));
    v2.push_back(C2.point(pi + base - ang));
    return 4;
}
double polygonarea(Point *p, int n) {
    double area = 0;
    for (int i = 1; i <= n - 1; i++) {
        area += cross(p[i] - p[1], p[i + 1] - p[1]);
    }
    return area / 2;
}
int inpoly(Point p, Point *Poly, int n) {
    int wn = 0;
    for (int i = 1; i <= n; i++) {
        if (onseg(p, Poly[i], Poly[(i + 1) % n])) return -1;
        int k = sgn(cross(Poly[(i + 1) % n] - Poly[i], p - Poly[i]));
        int d1 = sgn(Poly[i].y - p.y);
        int d2 = sgn(Poly[(i + 1) % n].y - p.y);
        if (k > 0 && d1 <= 0 && d2 > 0)  wn++;
        if (k < 0 && d2 <= 0 && d1 > 1)  wn--;
    }
    if (wn != 0) return 1;
    return 0;
}
int convexhull(Point *p, int n, Point *Poly) {
    sort(p + 1, p + n + 1);
    int m = 0;
    for (int i = 1; i <= n; i++) {
        while (m > 1 && cross(Poly[m] - Poly[m - 1], p[i] - Poly[m - 1]) >= 0) m--;
        Poly[++m] = p[i];
    }
    return m;
}
double hulldiam(Point *p, int n){
    double ans=0;
    p[n+1]=p[1];
    for(int i=1,j=2;i<n;i++)
    {
        while(j<=n&&areatri(p[i],p[i+1],p[j])<areatri(p[i],p[i+1],p[j+1]))j=j%n+1;
        ans=max(ans,length(p[i],p[j]));
        ans=max(ans,length(p[i+1],p[j]));
    }
    return ans;
}
bool anglecmp(Point a,Point b)
{return cross(a,b)!=0?cross(a,b)>0:length(a)<length(b);}
void anglesort(Point *a,int n)
{
    if(n==0)return;
    sort(a+1,a+1+n);
    for(int i=2;i<=n;i++)a[i]=a[i]-a[1];
    sort(a+2,a+1+n,anglecmp);
    for(int i=2;i<=n;i++)a[i]=a[i]+a[1];
}
int Minkovski(Point *a,int n,Point *b,int m,Point *c)
{
    // for(int i=1;i<=n;i++)debug(a[i].x,a[i].y);
    // for(int i=1;i<=m;i++)debug(b[i].x,b[i].y);
    int r=0;
    if(n==0)
    {for(int i=1;i<=m;i++)c[i]=b[i];r=m;return m;}
    if(m==0)
    {for(int i=1;i<=n;i++)c[i]=a[i];r=n;return n;}
    int i=1,j=1;
    while(i<=n&&j<=m)
    {
        //debug(i,j);
        c[++r]=a[i]+b[j];
        if(i==n&&j==m)break;
        if(i<n&&(j==m||cross(a[i+1]-a[i],b[j+1]-b[j])<0))i++;
        else if(i<n&&j<m&&cross(a[i+1]-a[i],b[j+1]-b[j])==0)i++,j++;
        else j++;
    }
    //for(int i=1;i<=r;i++)debug("!",c[i].x,c[i].y);
    return r;
}
const int maxn=1e6+10;
int n,a[maxn],b[maxn],c[maxn],tot;
Point A[maxn],B[maxn],C[maxn],ta[maxn],tb[maxn],tc[maxn],res[maxn];
int lena,lenb,lenc;
bool vis[maxn];
int main(){
    n=read();
    for(int i=0;i<=n;i++)a[i]=read(),ta[i+1]={i,a[i]};
    for(int i=0;i<=n;i++)b[i]=read(),tb[i+1]={i,b[i]};
    for(int i=0;i<=n;i++)c[i]=read(),tc[i+1]={i,c[i]};
    lena=convexhull(ta,n+1,A);
    lenb=convexhull(tb,n+1,B);
    lenc=convexhull(tc,n+1,C);
    tot=Minkovski(A,lena,B,lenb,res);
    lena=Minkovski(res,tot,C,lenc,A);
    //for(int i=1;i<=lena;i++)
    //    debug(A[i].x,A[i].y);
    //sort(A+1,A+1+lena,[&](Point a,Point b){return a.y<b.y;});
    for(int i=1;i<=lena;i++){
        vis[(int)A[i].x]=1;
    }
    vector<int> ans;
    for(int i=0;i<=3*n;i++)if(!vis[i])ans.push_back(i);
    write((int)ans.size()),io.pc('\n');
    for(int v:ans)
        write(v),io.pc(' ');
}
/*
3
3 1 8 7
9 1 3 1
5 1 1 6
*/