import java.io.*;
import java.util.*;
 
public class Main {
 
	void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	}

	void preCalc() {
 
	}
 
	void stress() {
 
	}
 
	void test() {
 
	}
 
	Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	}
 
	static final Random rng = new Random();
 
	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
 
	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}
 
	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
} import java.io.*; io.* java import java.util.*; util.* java public class Main {
 
	void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	}

	void preCalc() {
 
	}
 
	void stress() {
 
	}
 
	void test() {
 
	}
 
	Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	}
 
	static final Random rng = new Random();
 
	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
 
	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}
 
	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
} Main static final Random rng = new Random(); rng new Random() BufferedReader br; br PrintWriter out; out StringTokenizer st; st void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	} submit {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	} int N = nextInt(); N nextInt() nextInt int[] A1 = new int[N]; A1 new int[N] N int[] A2 = new int[N]; A2 new int[N] N for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    } int i=0; int i=0; i 0 i<N i N i++ i++ i {
	        A1[i] = nextInt();
	    } {
	        A1[i] = nextInt();
	    } A1[i] = nextInt() A1[i] A1 i nextInt() nextInt for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    } int i=0; int i=0; i 0 i<N i N i++ i++ i {
	        A2[i] = nextInt();
	    } {
	        A2[i] = nextInt();
	    } A2[i] = nextInt() A2[i] A2 i nextInt() nextInt int max_total=0; max_total 0 int tmp_total=0; tmp_total 0 for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    } int i=0; int i=0; i 0 i<N i N i++ i++ i {
	        tmp_total += A1[i];
	    } {
	        tmp_total += A1[i];
	    } tmp_total += A1[i] tmp_total A1[i] A1 i tmp_total += A2[N-1] tmp_total A2[N-1] A2 N-1 N 1 max_total = tmp_total max_total tmp_total tmp_total = 0 tmp_total 0 for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    } int i=0; int i=0; i 0 i<N i N i++ i++ i {
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    } {
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    } int j j k; k for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            } j=0; j=0 j 0 j<=i j i j++ j++ j {
            	tmp_total += A1[j];            
            } {
            	tmp_total += A1[j];            
            } tmp_total += A1[j] tmp_total A1[j] A1 j for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            } k=j-1; k=j-1 k j-1 j 1 k<N k N k++ k++ k {
                tmp_total += A2[k];
            } {
                tmp_total += A2[k];
            } tmp_total += A2[k] tmp_total A2[k] A2 k if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    } max_total < tmp_total max_total tmp_total {
    	        max_total = tmp_total;
    	    } max_total = tmp_total max_total tmp_total tmp_total = 0 tmp_total 0 out.println(max_total) out.println out max_total void preCalc() {
 
	} preCalc {
 
	} void stress() {
 
	} stress {
 
	} void test() {
 
	} test {
 
	} Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	} Main {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	} br = new BufferedReader(new InputStreamReader(System.in)) br new BufferedReader(new InputStreamReader(System.in)) out = new PrintWriter(System.out) out new PrintWriter(System.out) preCalc() preCalc submit() submit out.close() out.close out static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	} rand {
		return l + rng.nextInt(r - l + 1);
	} return l + rng.nextInt(r - l + 1); l + rng.nextInt(r - l + 1) l rng.nextInt(r - l + 1) rng.nextInt rng r - l + 1 r - l r l 1 int l l int r r public static void main(String[] args) throws IOException {
		new Main();
	} main {
		new Main();
	} new Main() String[] args args String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	} nextToken {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	} while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		} st == null || !st.hasMoreTokens() st == null st null !st.hasMoreTokens() st.hasMoreTokens() st.hasMoreTokens st {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		} try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			} catch (IOException e) {
				throw new RuntimeException(e);
			} IOException e {
				throw new RuntimeException(e);
			} throw new RuntimeException(e); new RuntimeException(e) {
				st = new StringTokenizer(br.readLine());
			} st = new StringTokenizer(br.readLine()) st new StringTokenizer(br.readLine()) return st.nextToken(); st.nextToken() st.nextToken st String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	} nextString {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	} try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		} catch (IOException e) {
			throw new RuntimeException(e);
		} IOException e {
			throw new RuntimeException(e);
		} throw new RuntimeException(e); new RuntimeException(e) {
			return br.readLine();
		} return br.readLine(); br.readLine() br.readLine br int nextInt() {
		return Integer.parseInt(nextToken());
	} nextInt {
		return Integer.parseInt(nextToken());
	} return Integer.parseInt(nextToken()); Integer.parseInt(nextToken()) Integer.parseInt Integer nextToken() nextToken long nextLong() {
		return Long.parseLong(nextToken());
	} nextLong {
		return Long.parseLong(nextToken());
	} return Long.parseLong(nextToken()); Long.parseLong(nextToken()) Long.parseLong Long nextToken() nextToken double nextDouble() {
		return Double.parseDouble(nextToken());
	} nextDouble {
		return Double.parseDouble(nextToken());
	} return Double.parseDouble(nextToken()); Double.parseDouble(nextToken()) Double.parseDouble Double nextToken() nextToken public class Main {
 
	void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	}

	void preCalc() {
 
	}
 
	void stress() {
 
	}
 
	void test() {
 
	}
 
	Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	}
 
	static final Random rng = new Random();
 
	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
 
	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}
 
	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
} public class Main {
 
	void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	}

	void preCalc() {
 
	}
 
	void stress() {
 
	}
 
	void test() {
 
	}
 
	Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	}
 
	static final Random rng = new Random();
 
	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
 
	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}
 
	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
} Main
import java.io.*;
import java.util.*;
 
public class Main {
 
	void submit() {
	    int N = nextInt();
	    int[] A1 = new int[N];
	    int[] A2 = new int[N];
	    
	    for(int i=0; i<N; i++){
	        A1[i] = nextInt();
	    }

	    for(int i=0; i<N; i++){
	        A2[i] = nextInt();
	    }
	    
	    int max_total=0;
	    int tmp_total=0;
	    
	    for(int i=0; i<N; i++){
	        tmp_total += A1[i];
	    }
	    tmp_total += A2[N-1];
	    max_total = tmp_total;
	    
	    
	    tmp_total = 0;
	     
	    for(int i=0; i<N; i++){
	        int j, k;
            for(j=0; j<=i; j++){
            	tmp_total += A1[j];            
            }
            for(k=j-1; k<N; k++){
                tmp_total += A2[k];
            }
    	    if(max_total < tmp_total){
    	        max_total = tmp_total;
    	    }
    	    tmp_total = 0;
	    }
	    
        out.println(max_total);
	}

	void preCalc() {
 
	}
 
	void stress() {
 
	}
 
	void test() {
 
	}
 
	Main() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		preCalc();
		submit();
		//stress();
		//test();
		out.close();
	}
 
	static final Random rng = new Random();
 
	static int rand(int l, int r) {
		return l + rng.nextInt(r - l + 1);
	}
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
 
	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return st.nextToken();
	}
 
	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
}