Problem: You are given k sequences of integers. The length of the i-th sequence equals to n_i.

You have to choose exactly two sequences i and j (i ≠ j) such that you can remove exactly one element in each of them in such a way that the sum of the changed sequence i (its length will be equal to n_i - 1) equals to the sum of the changed sequence j (its length will be equal to n_j - 1).

Note that it's required to remove exactly one element in each of the two chosen sequences.

Assume that the sum of the empty (of the length equals 0) sequence is 0.

Input

The first line contains an integer k (2 ≤ k ≤ 2 ⋅ 10^5) — the number of sequences.

Then k pairs of lines follow, each pair containing a sequence.

The first line in the i-th pair contains one integer n_i (1 ≤ n_i < 2 ⋅ 10^5) — the length of the i-th sequence. The second line of the i-th pair contains a sequence of n_i integers a_{i, 1}, a_{i, 2}, ..., a_{i, n_i}.

The elements of sequences are integer numbers from -10^4 to 10^4.

The sum of lengths of all given sequences don't exceed 2 ⋅ 10^5, i.e. n_1 + n_2 + ... + n_k ≤ 2 ⋅ 10^5.

Output

If it is impossible to choose two sequences such that they satisfy given conditions, print "NO" (without quotes). Otherwise in the first line print "YES" (without quotes), in the second line — two integers i, x (1 ≤ i ≤ k, 1 ≤ x ≤ n_i), in the third line — two integers j, y (1 ≤ j ≤ k, 1 ≤ y ≤ n_j). It means that the sum of the elements of the i-th sequence without the element with index x equals to the sum of the elements of the j-th sequence without the element with index y.

Two chosen sequences must be distinct, i.e. i ≠ j. You can print them in any order.

If there are multiple possible answers, print any of them.

Examples

Input

2
5
2 3 1 3 2
6
1 1 2 2 2 1


Output

YES
2 6
1 2


Input

3
1
5
5
1 1 1 1 1
2
2 3


Output

NO


Input

4
6
2 2 2 2 2 2
5
2 2 2 2 2
3
2 2 2
5
2 2 2 2 2


Output

YES
2 2
4 1

Note

In the first example there are two sequences [2, 3, 1, 3, 2] and [1, 1, 2, 2, 2, 1]. You can remove the second element from the first sequence to get [2, 1, 3, 2] and you can remove the sixth element from the second sequence to get [1, 1, 2, 2, 2]. The sums of the both resulting sequences equal to 8, i.e. the sums are equal.

Solution (in JAVA):

Solution:
import java.io.*;
import java.math.*;
import java.util.*;
import javax.print.attribute.SetOfIntegerSyntax;
 
public class Main2 {
    private static InputStream stream;
    private static byte[] buf = new byte[1024];
    private static int curChar;
    private static int numChars;
    private static SpaceCharFilter filter;
    private static PrintWriter pw;
    private static long count = 0,mod=1000000007,max=0;
    private static TreeSet<Integer>ts[]=new TreeSet[200000];
 
    public static void main(String args[]) throws Exception {
        InputReader(System.in);
        pw = new PrintWriter(System.out); 
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   soln();
                   pw.close();
               } catch(Exception e){
                   e.printStackTrace();
               }
           }
       },"1",1<<26).start();
    }
    //----------------------------------------My Code------------------------------------------------//
    //static int[] primefac;
    static ArrayList<Integer> primes;
    static void sieve(int n) {
    	boolean[] visited=new boolean[n];
    	visited[0]=visited[1]=true;
    	for(int i=2; i<n;i++) {
    		if(!visited[i]) {
    			primes.add(i);
    			for(int j=i+i;j<n;j+=i) {
    				visited[j]=true;
    			}
    		}
				
    	}
    }
    private static long countfac(int x) {
    	int n=x,i;
    	long ans=1;
    	for(i=0;i<=Math.sqrt(x);i++) {
    		int p=0;
    		while(x%primes.get(i)==0) {
    			p++;
    			x/=primes.get(i);
    		}
    		ans*=(p+1);
    	}
    	if(primes.get(i-1)<x) ans++;
    	return ans;
    }
    static class Strs implements Comparable<Strs>{
    	String s;
    	Strs(String s){
    		this.s = s;
    	}
    	@Override
    	public int compareTo(Strs o) {
    		if(this.s.contains(o.s)) return 1;
    		else if(o.s.contains(this.s)) return -1;
    		else return 0;
    	}
    }
    private static void soln(){
    	 int t = nextInt();
    	 int[][] arr = new int[t][];
    	 for(int i=0;i<t;i++) {
    		 int n = nextInt();
    		 arr[i] = nextIntArray(n);
    	 }
    	 int[] sum = new int[t];
    	 for(int i=0;i<t;i++) {
    		 for(int j=0;j<arr[i].length;j++) sum[i]+=arr[i][j];
    	 }
    	 int[][] summinuselement = new int[t][];
    	 summinuselement[0] = new int[arr[0].length];
    	 HashSet<Integer> hs = new HashSet<>();
    	 HashMap<Integer,Pair> hm = new HashMap<>();
    	 for(int i=0;i<arr[0].length;i++) {
    		 summinuselement[0][i] = sum[0] - arr[0][i];
    		 hs.add(summinuselement[0][i]);
    		 hm.put(summinuselement[0][i], new Pair(0,i,summinuselement[0][i]));
    		 
    	 }
    	 for(int i=1;i<t;i++) {
    		 HashSet<Integer> temp_hs = new HashSet<>();
    		 HashMap<Integer, Pair> temp_hm = new HashMap<>();
    		 for(int j=0;j<arr[i].length;j++) {
    			 Pair tmp = new Pair(i,j,sum[i] - arr[i][j]);
    			 if(hs.contains(sum[i]-arr[i][j])) {
    				 Pair match = hm.get(sum[i]-arr[i][j]);
    				 pw.println("YES");
    				 pw.println((match.idx_i+1) + " " + (match.idx_j+1));
    				 pw.println((tmp.idx_i+1) + " " + (tmp.idx_j+1));
    				 return;
    			 }
    			 temp_hs.add(sum[i]-arr[i][j]);
    			 temp_hm.put(sum[i]-arr[i][j], tmp);
    		 }
    		 hs.addAll(temp_hs);
    		 hm.putAll(temp_hm);
    	 }
    	 pw.println("NO");
    }
   
    
	static int ver=-1;
	private static void dfs(int root,LinkedList<Integer>[] adj,boolean[] visited){
		visited[root]=true;
		boolean flag=false;
		for(int x:adj[root]){
			if(!visited[x]){
				count++;
				//pw.println(count+" after incr at node " +root);
				dfs(x,adj,visited);
				flag=true;
				//pw.println(count+" at node "+root);
			}
		}
		if(!flag) {
			long prev=max;
			max=Math.max(count, max);
			if(prev!=max){
				ver=root;
				//arr[root]=(int)Math.max(arr[root], max);
			}
		}
		count--;
		
		visited[root]=false;
	}
	public static int fact(int n){
	    int ans=1;
	    for(int i=1;i<=n;i++) ans=(ans*i)%1000000007;
	    return ans;
	}
	//----------------------------------------THE END----------------------------------------------------------//            
	 
    static class Pair implements Comparable<Pair>{
 
       int idx_i,idx_j,val;
        Pair(int idx_i,int idx_j,int k){
            this.idx_i=idx_i;
            this.idx_j=idx_j;
            this.val=k;
            //this.l=l;
        }
        @Override
        public int compareTo(Pair o) {
           return Integer.compare(o.val, this.val); 
        }
        public int hashcode() {
        	return Integer.hashCode(val);
        }
        public boolean equals(Pair o) {
        	if(o.val == this.val) return true;
        	return false;
        }
    }
 
    public static long gcd(long x, long y) {
        if (x % y == 0)
            return y;
        else
            return gcd(y, x % y);
    }
    
    private static int BinarySearch(int a[], int low, int high, int target) {
        if (low > high)
            return -1;
        int mid = low + (high - low) / 2;
        if (a[mid] == target)
            return mid;
        if (a[mid] > target)
            high = mid - 1;
        if (a[mid] < target)
            low = mid + 1;
        return BinarySearch(a, low, high, target);
    }
    
    public static String reverseString(String s) {
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        return (sb.toString());
    }
 
    
    
    public static long pow(long n, long p, long m) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            if (result >= m)
                result %= m;
            p >>= 1;
            n *= n;
            if (n >= m)
                n %= m;
        }
        return result;
    }
 
    public static long pow(long n, long p) {
        long result = 1;
        if (p == 0)
            return 1;
        if (p == 1)
            return n;
        while (p != 0) {
            if (p % 2 == 1)
                result *= n;
            p >>= 1;
            n *= n;
        }
        return result;
 
    }
 
     public static int[] radixSort(int[] f) {
        int[] to = new int[f.length];
        {
            int[] b = new int[65537];
            for (int i = 0; i < f.length; i++)
                b[1 + (f[i] & 0xffff)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < f.length; i++)
                to[b[f[i] & 0xffff]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        {
            int[] b = new int[65537];
            for (int i = 0; i < f.length; i++)
                b[1 + (f[i] >>> 16)]++;
            for (int i = 1; i <= 65536; i++)
                b[i] += b[i - 1];
            for (int i = 0; i < f.length; i++)
                to[b[f[i] >>> 16]++] = f[i];
            int[] d = f;
            f = to;
            to = d;
        }
        return f;
    }
 
    public static int nextPowerOf2(final int a) {
        int b = 1;
        while (b < a) {
            b = b << 1;
        }
        return b;
    }
 
    public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
        int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
        int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;
 
        if ((s < 0) != (t < 0))
            return false;
 
        int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
        if (A < 0.0) {
            s = -s;
            t = -t;
            A = -A;
        }
        return s > 0 && t > 0 && (s + t) <= A;
    }
 
    public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
        return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
    }
 
    public static boolean isPrime(int n) {
        // Corner cases
        if (n <= 1)
            return false;
        if (n <= 3)
            return true;
 
        // This is checked so that we can skip 
    // middle five numbers in below loop
        if (n % 2 == 0 || n % 3 == 0)
            return false;
 
        for (int i = 5; i * i <= n; i = i + 6)
            if (n % i == 0 || n % (i + 2) == 0)
                return false;
 
        return true;
    }
 
    //merge Sort
 
    static long sort(int a[])
    {  int n=a.length;
        int b[]=new int[n];    
        return mergeSort(a,b,0,n-1);}
    static long mergeSort(int a[],int b[],long left,long right)
    { long c=0;if(left<right)
     {   long mid=left+(right-left)/2;
         c= mergeSort(a,b,left,mid);
         c+=mergeSort(a,b,mid+1,right);
         c+=merge(a,b,left,mid+1,right); }    
        return c;     }
    static long merge(int a[],int  b[],long left,long mid,long right)
    {long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
    while(i<=(int)mid-1&&j<=(int)right)
    { if(a[i]>a[j]) {b[k++]=a[i++]; }
    else    { b[k++]=a[j++];c+=mid-i;}}
    while (i <= (int)mid - 1)   b[k++] = a[i++]; 
    while (j <= (int)right) b[k++] = a[j++];
    for (i=(int)left; i <= (int)right; i++) 
        a[i] = b[i];  return c;  }
 
    // To Get Input
// Some Buffer Methods
 
    public static void InputReader(InputStream stream1) {
        stream = stream1;
    }
 
    private static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }
 
    private static boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }
 
    private static int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
 
    private static int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
        sgn = -1;
        c = read();
    }
    int res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
 
    private static long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
        sgn = -1;
        c = read();
    }
    long res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
 
    private static String nextToken() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }
 
    private static String nextLine() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndOfLine(c));
        return res.toString();
    }
 
    private static int[] nextIntArray(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextInt();
        }
        return arr;
    }
 
    private static int[][] next2dArray(int n, int m) {
        int[][] arr = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                arr[i][j] = nextInt();
            }
        }
        return arr;
    }
 
    private static long[] nextLongArray(int n) {
        long[] arr = new long[n];
        for (int i = 0; i < n; i++) {
            arr[i] = nextLong();
        }
        return arr;
    }
 
    private static void pArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static void pArray(long[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static void pArray(boolean[] arr) {
        for (int i = 0; i < arr.length; i++) {
            pw.print(arr[i] + " ");
        }
        pw.println();
        return;
    }
 
    private static boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }
 
    private interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
    
    
}