source_code: /*Author: Satyajeet Singh, Delhi Technological University*/
  import java.io.*;
  import java.util.*;
  import java.text.*; 
  import java.lang.*;
  
  public class Main {
  /*********************************************Constants******************************************/
      static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));        
      static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      static long mod=(long)1e9+7;
      static long mod1=998244353;
      static boolean sieve[];
      static ArrayList<Integer> primes;
      static ArrayList<Long> factorial;
      static HashSet<Integer> graph[];
  /****************************************Solutions Begins*****************************************/
      public static void main (String[] args) throws Exception {
          String st[]=br.readLine().split(" ");
          int n=Integer.parseInt(st[0]);
          long input[]=new long[n];
          st=br.readLine().split(" ");
          for(int i=0;i<n;i++){
              input[i]=Long.parseLong(st[i]);
          }
          HashMap<Long,ArrayList<Pair>> map=new HashMap<>();
          long pref[]=new long[n+1];
          pref[1]=input[0];
          for(int i=1;i<n;i++){
              pref[i+1]=pref[i]+input[i];
          }
          for(int i=0;i<n;i++){
              for(int j=i;j<n;j++){
                  long sum=pref[j+1]-pref[i];
                  if(!map.containsKey(sum)){
                      ArrayList<Pair> list=new ArrayList<>();
                      list.add(new Pair(i,j));
                      map.put(sum,list);
                  }
                  else{
                      ArrayList<Pair> list=map.get(sum);
                      list.add(new Pair(i,j));
                  }
              }
          }
          ArrayList<Pair> ans=new ArrayList<>();
         // debug(map);
          for(long keys:map.keySet()){
              ArrayList<Pair> list=map.get(keys);
              Collections.sort(list,new PairComp());
              int nn=list.size();
              for(int j=0;j<=0;j++){
                  ArrayList<Pair> cur=new ArrayList<>();
                  cur.add(list.get(j));
                  int lim=list.get(j).v;
                  int i=j;
                  while(i<nn){
                      if(list.get(i).u<=lim){
                          i++;
                      }
                      else{
                          cur.add(list.get(i));
                          lim=list.get(i).v;
                          i++;
                      }
                  }
                  if(ans.size()<cur.size()){
                      ans=cur;
                  }
              }
          }
          out.println(ans.size());
          for(Pair p:ans){
              out.println(++p.u+" "+ ++p.v);
          }
  /****************************************Solutions Ends**************************************************/
          out.flush();
          out.close();
      }
  /****************************************Template Begins************************************************/
  /***************************************Precision Printing**********************************************/
      static void printPrecision(double d){
          DecimalFormat ft = new DecimalFormat("0.00000000000000000"); 
          out.println(ft.format(d));
      }
  /******************************************Graph*********************************************************/
      static void Makegraph(int n){
          graph=new HashSet[n];
          for(int i=0;i<n;i++){
              graph[i]=new HashSet<>();
          }
      }
      static void addEdge(int a,int b){
          graph[a].add(b);
      }    
  /*********************************************PAIR********************************************************/
      static class PairComp implements Comparator<Pair>{
          public int compare(Pair p1,Pair p2){
              if(p1.v>p2.v){
                  return 1;
              }
              else if(p1.v<p2.v){
                  return -1;
              }
              else{
                  return p1.u-p2.u;
              }
          }
      }
      static class Pair implements Comparable<Pair> {
          int u;
          int v;
          int index=-1;
          public Pair(int u, int v) {
              this.u = u;
              this.v = v;
          }
   
          public int hashCode() {
              int hu = (int) (u ^ (u >>> 32));
              int hv = (int) (v ^ (v >>> 32));
              return 31 * hu + hv;
          }
   
          public boolean equals(Object o) {
              Pair other = (Pair) o;
              return u == other.u && v == other.v;
          }
   
          public int compareTo(Pair other) {
              if(index!=other.index)
                  return Long.compare(index, other.index);
              return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
          }
   
          public String toString() {
              return "[u=" + u + ", v=" + v + "]";
          }
      }
  
      static class PairCompL implements Comparator<Pairl>{
          public int compare(Pairl p1,Pairl p2){
              if(p1.v>p2.v){
                  return -1;
              }
              else if(p1.v<p2.v){
                  return 1;
              }
              else{
                  return 0;
              }
          }
      }
      static class Pairl implements Comparable<Pair> {
              long u;
              long v;
              int index=-1;
              public Pairl(long u, long v) {
                  this.u = u;
                  this.v = v;
              }
      
              public int hashCode() {
                  int hu = (int) (u ^ (u >>> 32));
                  int hv = (int) (v ^ (v >>> 32));
                  return 31 * hu + hv;
              }
      
              public boolean equals(Object o) {
                  Pair other = (Pair) o;
                  return u == other.u && v == other.v;
              }
      
              public int compareTo(Pair other) {
                  if(index!=other.index)
                      return Long.compare(index, other.index);
                  return Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u);
              }
      
              public String toString() {
                  return "[u=" + u + ", v=" + v + "]";
              }
          }
  /*****************************************DEBUG***********************************************************/
      public static void debug(Object... o) {
          System.out.println(Arrays.deepToString(o));
      }
  /************************************MODULAR EXPONENTIATION***********************************************/
      static long modulo(long a,long b,long c) {
          long x=1;
          long y=a;
          while(b > 0){
              if(b%2 == 1){
                  x=(x*y)%c;
              }
              y = (y*y)%c; // squaring the base
              b /= 2;
          }
          return  x%c;
      }
  /********************************************GCD**********************************************************/
      static long gcd(long x, long y)
      {
          if(x==0)
              return y;
          if(y==0)
              return x;
          long r=0, a, b;
          a = (x > y) ? x : y; // a is greater number
          b = (x < y) ? x : y; // b is smaller number
          r = b;
          while(a % b != 0)
          {
              r = a % b;
              a = b;
              b = r;
          }
          return r;
      }
  /******************************************SIEVE**********************************************************/
      static void sieveMake(int n){
          sieve=new boolean[n];
          Arrays.fill(sieve,true);
          sieve[0]=false;
          sieve[1]=false;
          for(int i=2;i*i<n;i++){
              if(sieve[i]){
                  for(int j=i*i;j<n;j+=i){
                      sieve[j]=false;
                  }
              }
          }
          primes=new ArrayList<Integer>();
          for(int i=0;i<n;i++){
              if(sieve[i]){
                  primes.add(i);
              }
          }        
      }
  /********************************************End***********************************************************/
  }