import java.util.*;
public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    }
       
}        import java.util.*; util.* java public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    }
       
} Main public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    } main {
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    } Scanner sc = new Scanner(System.in); sc new Scanner(System.in) int A = sc.nextInt(); A sc.nextInt() sc.nextInt sc int[]B = new int[A]; B new int[A] A for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        } int i = 0 ; int i = 0 ; i 0 i< A i A i++ i++ i {
            
            B[i]  = sc.nextInt();

        } {
            
            B[i]  = sc.nextInt();

        } B[i]  = sc.nextInt() B[i] B i sc.nextInt() sc.nextInt sc sc.close() sc.close sc int ans = 0; ans 0 for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        } int i = 0; int i = 0; i 0 i<A-1 i A-1 A 1 i++ i++ i {        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        } {        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        } int cnt = 0; cnt 0 for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            } int j = i; int j = i; j i j < A j A j++ j++ j {
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            } {
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            } if (j == A-1){
                    break;
                } j == A-1 j A-1 A 1 {
                    break;
                } break; if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                } B[j] >=B[j+1] B[j] B j B[j+1] B j+1 j 1 {
                    cnt++;
                // 比較終了
                } cnt++ cnt {
                    
                    break;

                } break; if (ans < cnt){
            
                ans = cnt;
            } ans < cnt ans cnt {
            
                ans = cnt;
            } ans = cnt ans cnt if (ans >= A-i){
                break;
            } ans >= A-i ans A-i A i {
                break;
            } break; System.out.println(ans) System.out.println System.out System System.out ans String[]args args public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    }
       
} public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    }
       
} Main
import java.util.*;
public class Main {
    public static void main(String[]args){
        Scanner sc = new Scanner(System.in);

        int A = sc.nextInt();

        int[]B = new int[A]; 
        
        for (int i = 0 ; i< A; i++){
            
            B[i]  = sc.nextInt();

        }

        sc.close();

        // 答えを初期化
        int ans = 0;
        // 配列に順次アクセス
        for (int i = 0;i<A-1;i++){        
            
            // 右隣への比較回数
            int cnt = 0;
            // jは配列のアクセスしている連番を示す
            for (int j = i;j < A;j++){
                // 最右に移動済みならループから抜ける
                if (j == A-1){
                    break;
                }
                
                //　右隣と比較
                if (B[j] >=B[j+1]){
                    cnt++;
                // 比較終了
                } else{
                    
                    break;

                }


            }
            // 移動回数が最大値を取っているならば答えを更新
            if (ans < cnt){
            
                ans = cnt;
            }
            
            if (ans >= A-i){
                break;
            }
        }
        System.out.println(ans);
    }
       
}       