source_code: import java.io.*;
  import java.math.BigInteger;
  import java.util.*;
  
  public class Main {
  	public static void main(String[] args) throws IOException {
  		InputStream inputStream = System.in;
  		OutputStream outputStream = System.out;
  		PrintWriter out = new PrintWriter(outputStream);
  		InputReader in = new InputReader(inputStream);
  		
  //		for(int i=4;i<=4;i++) {
  //			InputStream uinputStream = new FileInputStream("shortcut.in");
  //			String f = i+".in";
  //			InputStream uinputStream = new FileInputStream(f);
  //			InputReader in = new InputReader(uinputStream);
  //			PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("shortcut.out")));
  			Task t = new Task();
  			t.solve(in, out);
  			out.close();			
  //		}
  	}	
  	
  	static class Task {
  
  		public void solve(InputReader in, PrintWriter out) throws IOException {			
  			int n = in.nextInt();
  			int arr[] = in.readIntArray(n);
  			int v[][] = new int[n][n];
  			int c=0;
  			HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();
  			for(int i=0;i<n;i++) {
  				for(int j=i;j<n;j++) {
  					v[i][j] = arr[j];
  					if(j>i) v[i][j] += v[i][j-1]; 
  					if(!mp.containsKey(v[i][j])) mp.put(v[i][j], c++);
  				}
  			}
  			ArrayList<seg>[] all = new ArrayList[c];
  			for(int i=0;i<c;i++) all[i] = new ArrayList<seg>();
  			for(int i=0;i<n;i++) {
  				for(int j=i;j<n;j++) {
  					int idx = mp.get(v[i][j]);
  					all[idx].add(new seg(i,j,v[i][j]));
  				}
  			}
  			for(int i=0;i<c;i++) Collections.sort(all[i]);
  			int max = Integer.MIN_VALUE;
  			int val = -1;
  			for(int i=0;i<c;i++) {
  				if(all[i].size()==0) continue;
  				int num=1;
  				int p=0;int q=p+1;
  				while(q<all[i].size()) {
  					if(all[i].get(q).s>all[i].get(p).e) {
  						p=q;
  						num++;
  					}
  					q++;
  				}
  				if(num>max) {
  					max=num;
  					val = i;
  				}
  			}
  			out.println(max);
  			StringBuilder sb = new StringBuilder();
  			int p=0;int q=p+1;	
  			sb.append(all[val].get(0).toString());
  			while(q<all[val].size()) {
  				if(all[val].get(q).s>all[val].get(p).e) {
  					sb.append(all[val].get(q).toString());
  					p=q;
  				}
  				q++;
  			}
  			out.println(sb.toString());
  		}
  		public class seg implements Comparable<seg>{
  			int s; int e; int val;
  			public seg(int a, int b, int c) {
  				s=a;e=b;val=c;
  			}
  			@Override
  			public int compareTo(seg t) {
  				if(this.e==t.e) return this.s-t.s;				
  				return this.e-t.e;
  			}
  			public String toString() {
  				return (s+1)+" "+(e+1)+"\n";
  			}
  		}
  		public int GCD(int a, int b) {
  		   if (b==0) return a;
  		   return GCD(b,a%b);
  		}
  	}
  	
  	
      static class ArrayUtils {
          static final long seed = System.nanoTime();
          static final Random rand = new Random(seed);
  
          public static void sort(int[] a) {
              shuffle(a);
              Arrays.sort(a);
          }
  
          public static void shuffle(int[] a) {
              for (int i = 0; i < a.length; i++) {
                  int j = rand.nextInt(i + 1);
                  int t = a[i];
                  a[i] = a[j];
                  a[j] = t;
              }
          }
  
      }	
  	static class BIT{
  		int arr[];
  		int n;
  		public BIT(int a) {
  			n=a;
  			arr = new int[n];
  		}
  		int sum(int p) {
  			int s=0;
  			while(p>0) {
  				s+=arr[p];
  				p-=p&(-p);
  			}
  			return s;
  		}
  		void add(int p, int v) {
  			while(p<n) {
  				arr[p]+=v;
  				p+=p&(-p);
  			}
  		}
  	}
  	static class DSU{
  		int[] arr;
  		int[] sz;
  		public DSU(int n) {
  			arr = new int[n];
  			sz = new int[n];
  			for(int i=0;i<n;i++) arr[i] = i;
  			Arrays.fill(sz, 1);
  		}
  		public int find(int a) {
  			if(arr[a]!=a) arr[a] = find(arr[a]);
  			return arr[a];
  		}
  		public void union(int a, int b) {
  			int x = find(a);
  			int y = find(b);
  			if(x==y) return;
  			arr[x] = y;
  			sz[y] += sz[x];
  		}
  		public int size(int x) {
  			return sz[find(x)];
  		}
  	}	
  	static class MinHeap<Key> implements Iterable<Key> {
  		private int maxN;
  		private int n;
  		private int[] pq;
  		private int[] qp;
  		private Key[] keys;
  		private Comparator<Key> comparator;
  		
  		public MinHeap(int capacity){
  			if (capacity < 0) throw new IllegalArgumentException();
  			this.maxN = capacity;
  			n=0;
  			pq = new int[maxN+1];
  			qp = new int[maxN+1];
  			keys = (Key[]) new Object[capacity+1];
  			Arrays.fill(qp, -1);
  		}
  		
  		public MinHeap(int capacity, Comparator<Key> c){
  			if (capacity < 0) throw new IllegalArgumentException();
  			this.maxN = capacity;
  			n=0;
  			pq = new int[maxN+1];
  			qp = new int[maxN+1];
  			keys = (Key[]) new Object[capacity+1];
  			Arrays.fill(qp, -1);
  			comparator = c;
  		}			
  		public boolean isEmpty()	{ return n==0; 	}
  		public int size()			{ return n;		}
  		public boolean contains(int i) {
  	        if (i < 0 || i >= maxN) throw new IllegalArgumentException();
  	        return qp[i] != -1;
  		}	
  		public int peekIdx() {
  	        if (n == 0) throw new NoSuchElementException("Priority queue underflow");
  	        return pq[1];		
  		}	
  		public Key peek(){
  			if(isEmpty()) throw new NoSuchElementException("Priority queue underflow");
  			return keys[pq[1]];
  		}
  		public int poll(){
  			if(isEmpty()) throw new NoSuchElementException("Priority queue underflow");
  			int min = pq[1];
  			exch(1,n--);
  			down(1);
  			assert min==pq[n+1];
  			qp[min] = -1;
  			keys[min] = null;		
  			pq[n+1] = -1;
  			return min;
  		}
  	    public void update(int i, Key key) {
  	        if (i < 0 || i >= maxN) throw new IllegalArgumentException();
  	        if (!contains(i)) {
  	        	this.add(i, key);
  	        }else {
  	        	keys[i] = key;
  	        	up(qp[i]);
  	        	down(qp[i]);
  	        }
  	    }	
  		private void add(int i, Key x){
  	        if (i < 0 || i >= maxN) throw new IllegalArgumentException();
  	        if (contains(i)) throw new IllegalArgumentException("index is already in the priority queue");
  	        n++;
  	        qp[i] = n;
  	        pq[n] = i;
  	        keys[i] = x;
  	        up(n);
  		}
  		private void up(int k){
  			while(k>1&&less(k,k/2)){
  				exch(k,k/2);
  				k/=2;
  			}
  		}
  		private void down(int k){
  			while(2*k<=n){
  				int j=2*k;
  				if(j<n&&less(j+1,j)) j++;
  				if(less(k,j)) break;
  				exch(k,j);
  				k=j;
  			}
  		}
  		
  		public boolean less(int i, int j){
  	        if (comparator == null) {
  	            return ((Comparable<Key>) keys[pq[i]]).compareTo(keys[pq[j]]) < 0;
  	        }
  	        else {
  	            return comparator.compare(keys[pq[i]], keys[pq[j]]) < 0;
  	        }
  		}
  
  		public void exch(int i, int j){
  	        int swap = pq[i];
  	        pq[i] = pq[j];
  	        pq[j] = swap;
  	        qp[pq[i]] = i;
  	        qp[pq[j]] = j;
  		}
  
  		@Override
  		public Iterator<Key> iterator() {
  			// TODO Auto-generated method stub
  			return null;
  		}
  	}  	
  
      private static class InputReader
      {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int zcurChar;
          private int znumChars;
          private SpaceCharFilter filter;
  
          public InputReader(InputStream stream)
          {
              this.stream = stream;
          }
  
          public int read()
          {
              if (znumChars == -1)
                  throw new InputMismatchException();
              if (zcurChar >= znumChars)
              {
              	zcurChar = 0;
                  try
                  {
                      znumChars = stream.read(buf);
                  } catch (IOException e)
                  {
                      throw new InputMismatchException();
                  }
                  if (znumChars <= 0)
                      return -1;
              }
              return buf[zcurChar++];
          }
  
          public 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;
          }
  
          public String nextString()
          {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              StringBuilder res = new StringBuilder();
              do
              {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public double nextDouble()
          {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              int sgn = 1;
              if (c == '-')
              {
                  sgn = -1;
                  c = read();
              }
              double res = 0;
              while (!isSpaceChar(c) && c != '.')
              {
                  if (c == 'e' || c == 'E')
                      return res * Math.pow(10, nextInt());
                  if (c < '0' || c > '9')
                      throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              }
              if (c == '.')
              {
                  c = read();
                  double m = 1;
                  while (!isSpaceChar(c))
                  {
                      if (c == 'e' || c == 'E')
                          return res * Math.pow(10, nextInt());
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      m /= 10;
                      res += (c - '0') * m;
                      c = read();
                  }
              }
              return res * sgn;
          }
  
          public 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;
          }
  
          public boolean isSpaceChar(int c)
          {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          public String next()
          {
              return nextString();
          }
  
          public interface SpaceCharFilter
          {
              public boolean isSpaceChar(int ch);
          }
          public int[] readIntArray(int n) {
              int[] ret = new int[n];
              for (int i = 0; i < n; i++) {
                  ret[i] = nextInt();
              }
              return ret;
          }        
      }    
  
  	static class Dumper {
  		static void print_int_arr(int[] arr) {
  			for (int i = 0; i < arr.length; i++) {
  				System.out.print(arr[i] + " ");
  			}
  			System.out.println();
  			System.out.println("---------------------");
  		}
  
  		static void print_char_arr(char[] arr) {
  			for (int i = 0; i < arr.length; i++) {
  				System.out.print(arr[i] + " ");
  			}
  			System.out.println();
  			System.out.println("---------------------");
  		}
  
  		static void print_double_arr(double[] arr) {
  			for (int i = 0; i < arr.length; i++) {
  				System.out.print(arr[i] + " ");
  			}
  			System.out.println();
  			System.out.println("---------------------");
  		}
  
  		static void print_2d_arr(int[][] arr, int x, int y) {
  			for (int i = 0; i < x; i++) {
  				for (int j = 0; j < y; j++) {
  					System.out.print(arr[i][j] + " ");
  				}
  				System.out.println();
  			}
  			System.out.println();
  			System.out.println("---------------------");
  		}
  
  		static void print_2d_arr(boolean[][] arr, int x, int y) {
  			for (int i = 0; i < x; i++) {
  				for (int j = 0; j < y; j++) {
  					System.out.print(arr[i][j] + " ");
  				}
  				System.out.println();
  			}
  			System.out.println();
  			System.out.println("---------------------");
  		}
  
  		static void print(Object o) {
  			System.out.println(o.toString());
  		}
  
  		static void getc() {
  			System.out.println("here");
  		}
  	}
  }