Polycarp loves ciphers. He has invented his own cipher called Right-Left.Right-Left cipher is used for strings. To encrypt the string $$$s=s_{1}s_{2} \dots s_{n}$$$ Polycarp uses the following algorithm:  he writes down $$$s_1$$$,  he appends the current word with $$$s_2$$$ (i.e. writes down $$$s_2$$$ to the right of the current result),  he prepends the current word with $$$s_3$$$ (i.e. writes down $$$s_3$$$ to the left of the current result),  he appends the current word with $$$s_4$$$ (i.e. writes down $$$s_4$$$ to the right of the current result),  he prepends the current word with $$$s_5$$$ (i.e. writes down $$$s_5$$$ to the left of the current result),  and so on for each position until the end of $$$s$$$. For example, if $$$s$$$="techno" the process is: "t" $$$\to$$$ "te" $$$\to$$$ "cte" $$$\to$$$ "cteh" $$$\to$$$ "ncteh" $$$\to$$$ "ncteho". So the encrypted $$$s$$$="techno" is "ncteho".Given string $$$t$$$ — the result of encryption of some string $$$s$$$. Your task is to decrypt it, i.e. find the string $$$s$$$.

The only line of the input contains $$$t$$$ — the result of encryption of some string $$$s$$$. It contains only lowercase Latin letters. The length of $$$t$$$ is between $$$1$$$ and $$$50$$$, inclusive.

Print such string $$$s$$$ that after encryption it equals $$$t$$$.

//package codeforces;

import java.util.Arrays;
import java.util.Scanner;

public class LeftRightShifr {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String shifr = scanner.nextLine();
		char[] word = new char[shifr.length()];
		int middle = 0;
		if (shifr.length() % 2 == 0)
			middle = shifr.length() / 2 - 1;
		else
			middle = shifr.length() / 2;

			word[0] = shifr.charAt(middle);

		int k = 1;

		for (int i = 1; i < word.length && k < word.length; i++) {
			word[k] = shifr.charAt(middle + i);
			if (k == word.length - 1)
				break;
			else
				word[k + 1] = shifr.charAt(middle- i);
			k = k + 2;

		}
		System.out.println(new String(word));
		scanner.close();

	}

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Test22 {
    public static void main(String[] args) throws Exception{
        read();
    }public static void read() throws Exception{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

        String string=in.readLine().replace(" ", "");
        in.close();

        char[] chars=string.toCharArray();
        StringBuilder sb=new StringBuilder();

        int stringLenght=string.length();
        int middle=stringLenght%2==0?stringLenght/2-1:((int)stringLenght/2);
        if(stringLenght==1){
            sb.append(chars[0]);
        }if(stringLenght>1){
            sb.append(chars[middle]);
        }

        boolean isRight=true;
        int addRight=0;
        int addLeft=0;
        for(int i=1;i<stringLenght;i++){
            if(isRight){
                addRight++;
                if(middle+addRight<stringLenght)
                    sb.append(chars[middle+addRight]);
                isRight=!isRight;
            }else{
                addLeft++;
                if(middle-addLeft>=0)
                    sb.append(chars[middle-addLeft]);
                isRight=!isRight;
            }
        }

        function(sb.toString());
    }public static void function(String string) throws Exception{
        BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
        out.write(string);
        out.close();
    }
}

import java.util.*;
import java.io.*;
public class Main
{

	public static void main(String[] args) {

		InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskF solver = new TaskF();
        solver.solve(1, in, out);
        out.close();
	}

	static class TaskF
	{
	    public void solve(int testNumber, InputReader in, PrintWriter out) {
	    		StringBuffer result = new StringBuffer();
	    		String str = in.next();
	    		int n = str.length();

	    		if(n > 1){
		    		if(n % 2 == 0){
			    		result.append(str.charAt(n/2 - 1));
			    		for(int i = 1; i < n/2;i++)
			    			{
			    				result.append(str.charAt(n/2 + i-1));
			    				result.append(str.charAt(n/2 - i-1));
			    			}
			    		result.append(str.charAt(str.length() - 1));
			    	}

			    	else
			    	{
			    		result.append(str.charAt(n/2));
			    		for(int i = 1;i<=n/2;i++)
			    		{
			    			result.append(str.charAt(n/2 + i));
			    			result.append(str.charAt(n/2 - i));
			    		}
			    	}
		    		out.println(result);

	    		}
	    		else
	    			out.println(str);
	    }
	}

	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}

import java.util.*;
public class Problem1087a {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        int n = s.length();
        if (n > 1) {
            if(n%2 == 0) {
                for (int i = 1; i < n/2+1; i++) {
                    System.out.print(s.charAt(n / 2 - i) + "" + s.charAt(n / 2 + i - 1));
                }
            }
            else {
                for(int i = 1; i < n/2+1; i++){
                    System.out.print(s.charAt(n/2+1-i) + "" + s.charAt(n/2+i));
                }
                System.out.print(s.charAt(0));
            }
        }
        else {
            System.out.print(s);
        }
    }
}

import java.io.*;
public class Main
{
	public static void main(String[] args) throws IOException {
	    InputStreamReader isr = new InputStreamReader(System.in);
	    BufferedReader br= new BufferedReader (isr);
	    String s=br.readLine();
	    char c[]=s.toCharArray();
	    String str;
	    String str1="";
	    int mid=(s.length()-1)/2;
	    if (s.length()==1)
	    {
	        str1=str1+c[0];
	        	System.out.println(str1);
	    }
	    else
	    {
	        if (s.length()%2==0)
	   {
	    for (int i=s.length()-1,j=0;i>=0&&j<=mid;i--,j++)
	    {

	           str="";
	            str=str+c[j]+c[i];
	            str1=str+str1;

	    }
	          	System.out.println(str1);
	    }
	    else
	    {
	           for (int i=s.length()-1,j=0;i>=0&&j<=mid;i--,j++)
	    {

	           str="";
	            str=str+c[i]+c[j];
	            str1=str+str1;

	    }
	       char d[]=str1.toCharArray();
	       String str2="";
	       for (int i=1;i<str1.length();i++)
	       {
	           str2=str2+d[i];
	       }

	       System.out.println(str2);
	    }

	    }

	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Tutorial {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String t = br.readLine();
		int n = t.length();
		int i;
		int j;
		if (n % 2 == 0) {
			i = n / 2 - 1;
			j = n / 2;
		} else {
			i = n / 2;
			j = n / 2 + 1;
		}
		StringBuilder sb = new StringBuilder();
		while (i >= 0 && j < n) {
			if (sb.length() % 2 == 0) {
				sb.append(t.charAt(i));
				i -= 1;
			} else {
				sb.append(t.charAt(j));
				j += 1;
			}
		}
		if (n % 2 == 0)
			sb.append(t.charAt(n - 1));
		else {
			sb.append(t.charAt(0));
		}
		System.out.println(sb);

	}

}

import java.util.Collections;
import java.util.Scanner;
import java.util.Vector;

public class Main {

	public static void main(String[] args) {

		Scanner in=new Scanner(System.in);

		String dec=null;

		dec=in.next();

		int oddvalue=(dec.length()-1)/2;

		int evenvalue=oddvalue+1;

		// 4   1    5

		Vector<String> oddvalues=new Vector();
	String enc=dec.substring(oddvalue,oddvalue+1);
	for(int i=0;i<oddvalue;i++)
	{

		oddvalues.add(dec.substring(i,i+1));

	}
	Vector<String> evenvalues=new Vector<>();
	for(int i=oddvalue+1;i<dec.length();i++)
	{

		evenvalues.add(dec.substring(i,i+1));

	}

Collections.reverse(oddvalues);

	int c1=0,c2=0;
	for(int i=0;i<dec.length()-1;i++)
	{

		if(true)
		{
			if(i%2==0&&c1<evenvalues.size())
			{

				enc+=evenvalues.get(c1++).toString();

			}
			else if(i%2==1&&c2<oddvalues.size())
			{
				enc+=oddvalues.get(c2++).toString();
			}

		}
	}

		System.out.println(enc);

	}

}

import java.util.Scanner;

public class Codeforces {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String t=in.next();
        StringBuffer at=new StringBuffer();
        int k=(t.length()-1)/2;
        int i=0,j=0;
        for (i=k,j=k+1;i>=0&&j<t.length();i--,j++){
            at.append(t.charAt(i));
            at.append(t.charAt(j));
        }
        while(i>=0){
            at.append(t.charAt(i--));
        }
        while (j<t.length())
            at.append(t.charAt(j++));

        System.out.println(at.toString());

    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class Main {

	static class Task {

		int NN = 200005;
		int MOD = 1000000007;
		int INF = 2000000000;
		long INFINITY = 2000000000000000000L;

		public void solve(InputReader in, PrintWriter out) {
			String s = in.next();
			StringBuilder sb = new StringBuilder(s);
			int e = s.length() / 2;
			int j = 2;
			for(int i=s.length()-e;i<s.length();++i) {
				sb.setCharAt(j - 1, s.charAt(i));j+=2;
			}
			j = 1;
			for(int i=s.length()-e-1;i>=0;--i) {
				sb.setCharAt(j - 1, s.charAt(i));j+=2;
			}
			out.println(sb.toString());
		}

	}

	static void prepareIO(boolean isFileIO) {
		//long t1 = System.currentTimeMillis();
		Task solver = new Task();
		// Standard IO
		if(!isFileIO) {
			InputStream inputStream = System.in;
	        OutputStream outputStream = System.out;
	        InputReader in = new InputReader(inputStream);
	        PrintWriter out = new PrintWriter(outputStream);
	        solver.solve(in, out);
	        //out.println("time(s): " + (1.0*(System.currentTimeMillis()-t1))/1000.0);
	        out.close();
		}
        // File IO
		else {
			String IPfilePath = System.getProperty("user.home") + "/Downloads/ip.in";
	        String OPfilePath = System.getProperty("user.home") + "/Downloads/op.out";
	        InputReader fin = new InputReader(IPfilePath);
	        PrintWriter fout = null;
	        try {
				fout = new PrintWriter(new File(OPfilePath));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
	        solver.solve(fin, fout);
	        //fout.println("time(s): " + (1.0*(System.currentTimeMillis()-t1))/1000.0);
	        fout.close();
		}
	}

	public static void main(String[] args) {
        prepareIO(false);
	}

	static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public InputReader(String filePath) {
        	File file = new File(filePath);
            try {
				reader = new BufferedReader(new FileReader(file));
			} catch (FileNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            tokenizer = null;
        }

        public String nextLine() {
        	String str = "";
        	try {
				str = reader.readLine();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
        	return str;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
        	return Double.parseDouble(next());
        }

    }

}

import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;
public class BCF425A {
    public static void main(String[]args)throws Exception
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(br.readLine());
        char cc[] = st.nextToken().toCharArray();
       StringBuilder sb = new StringBuilder();
       int a = 0;
       int b = cc.length-1;
       int ct = 1;
       if(cc.length%2!=0)
           ct*=-1;
       while(b>=a)
       {
           if(ct==1)
           {
               sb.append(cc[b]);
               b--;
           }
           else
           {
               sb.append(cc[a]);
               a++;
           }
           ct*=-1;
       }
//       System.out.println(sb.toString());
       String res = sb.reverse().toString();
       System.out.println(res);

    }
}

import java.io.*;
import java.util.*;

public class Main {

    static StringBuilder data = new StringBuilder();
    final static FastReader in = new FastReader();

    public static void main(String[] args) {
        String s =in.nextLine();
        char []a = new char[s.length()];
        int l=0,r=s.length()-1,j=s.length()-1;
        for (int i = s.length()-1; i >=0 ; i--) {
            if(i%2==0){
                a[j]=s.charAt(l);
                l++;
            }else{
                a[j]=s.charAt(r);
                r--;
            }
            j--;
        }
        System.out.println(a);
    }

    static void fileOut(String s) {
        File out = new File("output.txt");
        try {
            FileWriter fw = new FileWriter(out);
            fw.write(s);
            fw.flush();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        public FastReader(String path) {
            try {
                br = new BufferedReader(new
                        InputStreamReader(new FileInputStream(path)));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        float nextFloat() {
            return Float.parseFloat(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}

/*package whatever //do not write package name here */

import java.io.*;

public class GFG {
	public static void main (String[] args) throws IOException {
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		String s=in.readLine();
		int i=0,j=s.length()-1;
		String t="";
		if(s.length()%2==0){
		for(;i<s.length()/2;i++,j--)
		{
		    t=s.charAt(i)+""+s.charAt(j)+""+t;
		}}
		else{
		for(;i<s.length()/2;i++,j--)
		{
		    t=s.charAt(j)+""+s.charAt(i)+""+t;
		}}
		if(s.length()%2!=0)
		t=s.charAt(s.length()/2)+""+t;
		System.out.println(t);
	}
}

import java.util.Scanner;

public class RightLeftCipher {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        StringBuilder sb = new StringBuilder();
        if(s.length()==1){
            System.out.println(s);
            return;
        }
        int index = (int)Math.ceil(s.length() / (double)2) -1;
        sb.append(s.charAt(index));
        for (int i = 1; i < s.length(); i++) {
            if(i%2==0){
                index = index - i;
            }else {
                index = index + i;
            }
            sb.append(s.charAt(index));
        }
        System.out.println(sb);
    }
}

import java.util.Scanner;

public class Cf_cipher {

    public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);

       int start;

    StringBuilder sb=new StringBuilder("");

    String ip=sc.next();

    if(ip.length()%2==0){
        start=(ip.length())/2-1;
    }
    else{
        start=((ip.length())/2);
    }

    sb.append(ip.charAt(start));
     //  System.out.println("Strt:-"+sb);

       int fwrd=start+1;
       int backwrd=start-1;

   while(fwrd<=ip.length() && backwrd>=0){

       if(fwrd<=ip.length()){
           sb.append(ip.charAt(fwrd));
           fwrd=fwrd+1;
       }

       if(backwrd>=0){
       sb.append(ip.charAt(backwrd));
      backwrd=backwrd-1;
     }

      // System.out.println(sb);
    }

    String neww=sb.toString();

     if(ip.length()%2==0){
       neww=neww+ip.charAt(ip.length()-1);
    }

        System.out.println(neww);

    }

}

import java.util.*;
import java.io.*;
//import javafx.util.Pair;
public class Main implements Runnable
{

    static class Pair implements Comparable <Pair>
    {
        int x,y;
        Pair(int x,int y)
        {
            this.x=x;
            this.y=y;
        }
        public int compareTo(Pair p)
        {
            if(x==p.x)
                return Integer.compare(y,p.y);
            return Integer.compare(x,p.x);
        }
    }

    public static void main(String[] args)
    {
        new Thread(null, new Main(), "rev", 1 << 29).start();
    }

    public void run()
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1,in,out);
        out.close();
    }

    static class Task
    {
        void solve(int testNumber, InputReader in, PrintWriter out)
        {
            String s=in.nextString();
            int n=s.length();
            if(n%2==1)
            {
                out.print(s.charAt(n/2));
                for(int i=1;n/2-i>=0;i++)
                    out.print(s.charAt(n/2+i)+""+s.charAt(n/2-i));
            }
            else
                for(int i=1;n/2-i>=0;i++)
                    out.print(s.charAt(n/2-i)+""+s.charAt(n/2+i-1));
        }
    }
    /*static class OutputWriter
    {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream)
        {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer)
        {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects)
        {
            for(int i=0;i<objects.length;i++)
            {
                if (i!=0)
                {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects)
        {
            print(objects);
            writer.println();
        }

        public void close()
        {
            writer.close();
        }
    }*/

static class InputReader
{
    private InputStream stream;
    private byte[] buf = new byte[8192];
    private int curChar, snumChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream)
    {
        this.stream = stream;
    }

    public int snext()
    {
        if(snumChars==-1)
            throw new InputMismatchException();
        if(curChar>=snumChars)
        {
            curChar=0;
            try
            {
                snumChars = stream.read(buf);
            }
            catch(IOException e)
            {
                throw new InputMismatchException();
            }
            if(snumChars<=0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = snext();
        while(isSpaceChar(c))
            c=snext();
        int sgn=1;
        if(c=='-')
        {
            sgn = -1;
            c = snext();
        }
        int res=0;
        do
        {
            if(c<'0' || c>'9')
                throw new InputMismatchException();
            res*=10;
            res+=c-'0';
            c=snext();
            }while(!isSpaceChar(c));
        return res * sgn;
    }

    public long nextLong()
    {
        int c = snext();
        while(isSpaceChar(c))
            c=snext();
        int sgn=1;
        if(c=='-')
        {
            sgn=-1;
            c=snext();
        }
        long res=0;
        do{
            if (c<'0' || c>'9')
                throw new InputMismatchException();
            res*=10;
            res+=c-'0';
            c=snext();
        }while (!isSpaceChar(c));
        return res * sgn;
    }

    public int[] nextIntArray(int n)
    {
        int a[]=new int[n];
        for(int i=0; i<n; i++)
            a[i]=nextInt();
        return a;
    }

    public long[] nextLongArray(int n)
    {
        long a[]=new long[n];
        for(int i=1; i<n; i++)
            a[i]=nextLong();
        return a;
    }
    public String nextString()
    {
        int c=snext();
        while(isSpaceChar(c))
            c=snext();
        StringBuilder res=new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = snext();
        }while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c)
    {
        if(filter != null)
            return filter.isSpaceChar(c);
        return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}
}

import javafx.util.Pair;
import org.omg.CORBA.INTERNAL;
import sun.awt.image.ImageWatched;
import sun.reflect.generics.tree.Tree;

import java.lang.reflect.Array;
import java.nio.channels.ScatteringByteChannel;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner s =  new Scanner(System.in);

        String encrypted = s.next();

        int length = encrypted.length();

        char[] result = new char[length];

        int oddStart = length % 2 == 0 ? length -2 : length-1;
        int index = 0;
        for ( ; oddStart >=  0; oddStart-=2 , index++) {

            result[oddStart] = encrypted.charAt(index);
        }

        for (int evenStart= 1;  evenStart < length; evenStart+=2, index++) {

            result[evenStart] = encrypted.charAt(index); //띠용
        }

        for (char k : result) {

            System.out.print(k);
        }
    }

}

import java.io.*;
import java.util.*;

public class Main {
    void solve () {
        String str=readString();
        if (str.length()%2==0){
            int l=0;
            for (int i=0;i<str.length()/2;i++){
                out.print(str.charAt(str.length()/2-l-1)+""+str.charAt(str.length()/2+l));
                l++;
            }
        }
        else{
            int l=1;
            out.print(str.charAt(str.length()/2));
            for (int i=0;i<(str.length()-1)/2;i++){
                out.print(str.charAt(str.length()/2+l)+""+str.charAt(str.length()/2-l));
                l++;
            }
        }
    }
    public static void main(String[] args) {
        new Main().run();

    }
    private void run() {
        try {
            init();
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }
    }

    private BufferedReader in;
    private StringTokenizer tok = new StringTokenizer("");

    private PrintWriter out;

    private void init() throws FileNotFoundException {
        in = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
    }

    private String readLine() {
        try {
            return in.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private String readString() {
        while (!tok.hasMoreTokens()) {
            String nextLine = readLine();
            if (nextLine == null) return null;
            tok = new StringTokenizer(nextLine);
        }

        return tok.nextToken();
    }

    private int readInt() {
        return Integer.parseInt(readString());
    }
    private long readLong(){
        return Long.parseLong(readString());
    }
    private double readDouble(){
        return Double.parseDouble(readString());
    }

}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author yousefbj
 */
public class Main{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         String text = sc.next();

         StringBuilder sb = new StringBuilder();
         if(text.length()==1){
             System.out.println(text);
         }else if(text.length()%2==0){
         for (int i = 1; i < text.length()/2+1; i++) {
            sb.append(text.substring(text.length()/2-i, text.length()/2-i+1));
            sb.append(text.substring(text.length()/2+i-1, text.length()/2+i));
        }
         System.out.println(sb);
         }else{
             int count=1;
              for (int i = 0; i < text.length()/2+1; i++) {
            sb.append(text.substring(text.length()/2-i, text.length()/2-i+1));
            if(count!=text.length()/2+1){
            sb.append(text.substring(text.length()/2+i+1, text.length()/2+i+2));
            }
            count++;
              }
         System.out.println(sb);
         }
    }

}

import java.io.*;
import java.math.*;
import java.util.*;

public class poogramA {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str1 = br.readLine();
		int n = str1.length();
		if(n==1)System.out.println(str1);
		else {
			int mid =0;
			if(n%2 == 0) {
		 mid = n/2-1;}
			else {
			mid = n/2;
			}
		String ans = Character.toString(str1.charAt(mid));
		int x=1,j=1;
		for(int i=1;i<n;i++) {
			if(i%2 == 1) {
				String temp = Character.toString(str1.charAt(mid+x));
				ans+=temp;
				x++;
			}
			else {
				String temp2 = Character.toString(str1.charAt(mid-j));
				ans+=temp2;
				j++;
			}
		}
		System.out.println(ans);
		}
	}
}

import java.util.Scanner ;
public class A_1085
{
    public static void main(String [] args)
    {
        Scanner sc = new Scanner(System.in);
        String t = sc.next();
        if(t.length() % 2 == 0)
        {
            for(int i = 0; i < (t.length()/2); i++)
                System.out.print(t.charAt(t.length()/2-1-i) + "" + t.charAt(t.length()/2+i));
        }
        else
        {
            System.out.print(t.charAt(t.length()/2));
            for(int i = 0; i < (t.length()/2); i++)
                System.out.print(t.charAt(t.length()/2+1+i) + "" + t.charAt(t.length()/2-1-i));
        }
    }
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.*;
public final class GFG {
	public static void main (String[] args) {
		Scanner ob  = new Scanner(System.in);
		String str = ob.next();
		String res = "";

	    while(str.length()>1){
	        if(str.length()%2==0){
	            res = Character.toString(str.charAt(str.length()-1)) + res;
	            str = str.substring(0,str.length()-1);
	        }
	        else{
	            res = Character.toString(str.charAt(0)) + res;
	            str = str.substring(1,str.length());
	        }
	    }
	    res=str+res;
		System.out.println(res);
	}
}

import java.util.Scanner;
import java.util.Stack;

public class pre42
{
    public static void main(String args[])
    {
        Scanner obj = new Scanner(System.in);
        String str = obj.next();
        int i=0,j=str.length()-1;
        Stack<Character> stack = new Stack<>();
        if(str.length()%2==0)
        {
            while (j>i)
            {
                stack.push(str.charAt(j));
                j--;
                stack.push(str.charAt(i));
                i++;
            }
        }
        else
        {
            while (j!=i)
            {
                stack.push(str.charAt(i));
                i++;
                stack.push(str.charAt(j));
                j--;
            }
            stack.push(str.charAt(j));
        }
        while (!stack.isEmpty())
            System.out.print(stack.pop());
    }
}

import java.util.*;
public class leftright
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int l = s.length();
        String st = "";
        if(l==1)
            System.out.println(s);
        else if((l-1)%2!=0)
        {
            boolean b = false;
            int c = 0;
            while(b==false)
            {
                char ch = s.charAt(l-c-1);
                st = ch + st;
                ch = s.charAt(c);
                st = ch + st;
                c++;
                if(c == l/2)
                    b = true;
            }
            System.out.println(st);
        }
        else
        {
            boolean b = false;
            int c = 0;
            while(b==false)
            {
                char ch = s.charAt(c);
                st = ch + st;
                ch = s.charAt(l-c-1);
                st = ch + st;
                c++;
                if(c == (l-1)/2 || c==l)
                    b = true;
            }
            if(c<l)
            st = s.charAt(c) + st;
            System.out.println(st);
        }
    }
}

import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    private void run() throws IOException {

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        String s = reader.readLine();
        int center = s.length() % 2 == 0 ? s.length()/2-1 : s.length() / 2;

        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        writer.write(s.charAt(center));
        for (int i = 1; true; i++) {
            if(center + i >= s.length()) break;
            else {
                writer.write(s.charAt(center + i));
                if(center - i >= 0) writer.write(s.charAt(center-i));
            }
        }
        writer.flush();

    }

}

import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }

    void solve() throws IOException {
        String s=next();
        StringBuilder A=new StringBuilder();
        int p=0;
        if (s.length()%2==1) { A.append(s.charAt(0)); p++; }
        int q=s.length()-1;
        while (p<q) {
            A.append(s.charAt(q));
            A.append(s.charAt(p));
            q--;
            p++;
        }
        A.reverse();
        System.out.println(A);
    }

    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}

import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.BufferedOutputStream;

public class RightLeftCipher{

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static PrintWriter out;
    public static void printArr(int[] arr){
        for(int i = 0;i<arr.length;i++){
            out.print(arr[i] + " ");
        }
        out.println();
    }
    public static void main(String[] args){
        FastReader s = new FastReader();
        out=new PrintWriter (new BufferedOutputStream(System.out));
        int t = 1;
        for(int u = 0;u<t;u++){
            String str = s.next();
            int l = 0;
            int r = str.length()-1;
            Boolean isOdd = false;
            if(str.length()%2!=0) isOdd = true;
            StringBuilder sb = new StringBuilder();
            Boolean left = isOdd ? true:false;
            while(l<=r){
                if(left){
                    sb.append(str.charAt(l));
                    l++;
                    left = false;
                }else{
                    sb.append(str.charAt(r));
                    r--;
                    left = true;
                }
            }
            System.out.println(sb.reverse().toString());
        }
        out.close();
    }

}

	import java.util.*;
	import java.lang.*;
	import java.text.DecimalFormat;
	import java.text.NumberFormat;
	import java.io.*;
	public class Solution {

		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;

	        public FastReader() {
	            br = new BufferedReader(new
	                    InputStreamReader(System.in));
	        }

	        static long gcd(long a, long b){
			      if (b == 0)
			        return a;
			      return gcd(b, a % b);
			}

	        String next() {
	            while (st == null || !st.hasMoreElements()) {
	                try{
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException  e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	        int nextInt() {
	            return Integer.parseInt(next());
	        }
	        long nextLong() {
	            return Long.parseLong(next());
	        }
		public int[] readIntArray(int n) {
				int[] arr = new int[n];
				for(int i=0; i<n; ++i)
					arr[i]=nextInt();
				return arr;
			}

	        double nextDouble() {
	            return Double.parseDouble(next());
	        }

	        String nextLine() {
	            String str = "";
	            try{
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
	    }
		static void solve(String str, int n) {
			if(str.length() == 1 || str.length() == 2) {
	        	System.out.println(str);
	        	return;
	        }
	        char[] arr = str.toCharArray();

	        StringBuilder sb = new StringBuilder();

	        int mid = n%2 == 0 ? n/2 : n/2+1;

	        sb.append(str.charAt(mid-1));
	        int i = mid - 1, j = mid + 1;
	       while(i >= 1 || j  <= n) {
	    	   if(j <= n) {
	    	   sb.append(str.charAt(j-1));
	    	   }
	    	  if(i >= 1) {
	    	   sb.append(str.charAt(i-1));
	    	   }
	    	   i--;
	    	   j++;
	        }
	       System.out.println(sb.toString());
		}

		public static void main(String args[]) {
	        FastReader sc = new FastReader();
	        long start = System.currentTimeMillis();

	        String str = sc.next();

	        solve(str, str.length());

	        	long end = System.currentTimeMillis();
	        	NumberFormat formatter = new DecimalFormat("#0.00000");
	        	//System.out.print("Execution time is " + formatter.format((end - start) / 1000d) + " seconds");
	        }
	}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class Main{
    public static void main(String[] args)throws IOException {
        FastReader in = new FastReader();
        OutputStream output = System.out;
        PrintWriter out = new PrintWriter(output);
        String s = in.next();
        int lenght = s.length();
        StringBuilder sb = new StringBuilder();
        int ind = (lenght / 2);
        if (lenght % 2 == 0) {
            ind -= 1;
        }
        if (ind < 0) {
            out.println(s);
        } else {
            sb.append(s.charAt(ind));
            int i = 1, j = -1;
            while (true) {
                if ((ind + i) < lenght) {
                    sb.append(s.charAt(ind + i));
                    i++;
                }
                else
                    break;
                if ((ind + j) >= 0) {
                    sb.append(s.charAt(ind + j));
                    j--;
                }
            }
            out.println(sb);
        }
        out.close();
    }
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.*;
public class A{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String s = scan.next();
		int n = s.length();
		int i = 0,j = n-1;
		StringBuilder ans =  new StringBuilder();
		while(i < j)
		{
			if(n%2 == 1)
			{
				ans.append(s.charAt(i));
				ans.append(s.charAt(j));
			}
			else
			{
				ans.append(s.charAt(j));
				ans.append(s.charAt(i));
			}

			i++;j--;
		}
		if(n%2 == 1)
			ans.append(s.charAt(i));
		System.out.println(ans.reverse());
	}
}

//package codeforces;
import java.util.ArrayDeque;
//import java.util.ArrayList;
import java.util.Deque;
import java.util.Scanner;

public class main {

	public static void main(String[] args) {

//		Scanner in = new Scanner(System.in);
//		String word = in.nextLine();
//
//		int length = word.length();
//		char[] arrInput = word.toCharArray();
//
//		int r, l = 0;
//		if (length % 2 == 0) {
//			r = length / 2 - 1;
//			l = r;
//		} else {
//			r = length / 2;
//			l = r;
//		}
//		char [] wordOuput = new char[length];
//		wordOuput[0] = arrInput[r];
//		for (int i = 1; i < length; i++) {
//			if(i%2==0){
//				l--;
//				wordOuput[i] = arrInput[l];
//			}else{
//				r++;
//				wordOuput[i] = arrInput[r];
//
//			}
//		}
//		for (int i = 0; i < length; i++) {
//			System.out.print(wordOuput[i]);
//		}

		Scanner in = new Scanner(System.in);
		String word = in.nextLine();
		int length = word.length();
		char[] arrInput = word.toCharArray();
		Deque<Character> dll = new ArrayDeque<>();
		for (int i = 0; i < length; i++) {
			dll.add(arrInput[i]);
		}
		char [] arrOutput = new char[length];
//		if(length%2 == 2){
			for (int i = length-1; i >= 0; i--) {
				if(i%2==1){
					arrOutput[i]=dll.pollLast();
//					System.out.println("i: "+i +" arr"+arrOutput[i]);

				}else{
					arrOutput[i]=dll.pollFirst();
//					System.out.println("i: "+i +" arr"+arrOutput[i]);

				}
			}
//		}else{
//			arrOutput[length-1]=dll.getFirst();
//		}
		for (int i = 0; i<length; i++) {
			System.out.print(arrOutput[i]);
		}
//		char [] arrInput = word.toCharArray();

	}

}

import java.util.Scanner;

public class Main {

	static String result = "";

	public static String fetchRight(String str) {

		result = str.charAt(str.length() - 1) + result;

		return str.substring(0, str.length()-1);

	}

	public static String fetchLeft(String str) {

		result = str.charAt(0) + result;

		return str.substring(1);

	}

	public static void main(String[] args) {

		Scanner cin = new Scanner(System.in);

		String str = cin.next();
		boolean bool = str.length() % 2 == 0 ? true : false;
		int len = str.length();

		for(int i = 0; i < len; i++) {

			if(bool == true) {

				str = fetchRight(str);
				bool = false;

			}else {

				str = fetchLeft(str);
				bool = true;

			}

		}

		System.out.println(result);

	}

}

import java.util.Scanner;

public class RightLeftCipher {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
String str= scan.next();
if(str.length()==1 || str.length()==2)
	System.out.println(str);
if(str.length()==3) {
	char[] B= new char[str.length()];
	B[0]=str.charAt(str.length()/2);
	int p= str.length()/2+1 ;
	int k= str.length()/2-1;
	for(int i=1; i<str.length(); i++) {
		if(i%2!=0) {
			B[i]=str.charAt(p);
		p++;
		}
		else {
			B[i]=str.charAt(k);
			k--;
		}
	}
	for(int i=0; i<B.length; i++) {
		System.out.print(B[i]);
}
}
if(str.length()>3) {
char[] A= new char[str.length()];
int p=0;
int k=0;
if(A.length%2!=0) {
A[0]=str.charAt(str.length()/2);
 p= str.length()/2+1 ;
 k= str.length()/2-1;
}
if(A.length%2==0) {
	A[0]= str.charAt(str.length()/2-1);
	 p=str.length()/2;
	 k=str.length()/2-2;
}
int i=1;
while(i<A.length && k>=0 ) {
	if(i%2!=0) {
		A[i]=str.charAt(p);

	p++;
	}
	else {
		A[i]=str.charAt(k);
	if(i!=str.length()-2 )
		k--;
	}
	i++;
}

for(int l=0; l<A.length; l++) {
	System.out.print(A[l]);
}

}

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Sri Mouli (sri.vcmk@gmail.com)
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        ARightLeftCipher solver = new ARightLeftCipher();
        solver.solve(1, in, out);
        out.close();
    }

    static class ARightLeftCipher {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            String cipher = in.next();
            out.printLine(decipher(cipher));
        }

        public String decipher(String a) {
            int t = a.length();
            StringBuilder sb = new StringBuilder();
            int lol = (t - 1) / 2;
            for (int i = 0; i < t; i++) {
                if (i % 2 == 0) {
                    sb.append(a.charAt(lol - ((i + 1) / 2)));
                } else {
                    sb.append(a.charAt(lol + ((i + 1) / 2)));
                }
            }
            return sb.toString();
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private BufferedReader br;
        private StringTokenizer st;

        public InputReader(InputStream inputStream) {
            br = new BufferedReader(new InputStreamReader(inputStream));
        }

        InputReader(String file) {
            try {
                br = new BufferedReader(new FileReader(file));
            } catch (FileNotFoundException ignored) {

            }
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class Main
{
	public static void main(String[] args)
	{
		String str,name="";
		Scanner sc=new Scanner(System.in);
		str=sc.next();
		int x=0,y=str.length()-1;
		if(str.length()%2==0)
		{
			for(int i=0;i<str.length();i++)
			{
				if(i%2==0)
				{
					name+=str.charAt(y);
					y--;
				}
				else
				{
					name+=str.charAt(x);
					x++;
				}
			}
		}
		else
		{
			for(int i=0;i<str.length();i++)
			{
				if(i%2==0)
				{
					name+=str.charAt(x);
					x++;
				}
				else
				{
					name+=str.charAt(y);
					y--;
				}
			}
		}
		String[] arr=name.split("");
		for(int i=arr.length-1;i>=0;i--)
		{
			System.out.print(arr[i]);
		}
	}
}

import java.io.*;
import java.util.*;

public class RightLeftCipher {

    public static String solve(String s) {
        if (s.length() == 1)
            return s;

        if (s.length() % 2 == 0) {
            return solve(s.substring(0, s.length() - 1)) + s.charAt(s.length() - 1);
        } else {
            return solve(s.substring(1)) + s.charAt(0);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String s = sc.nextLine();

        System.out.println(solve(s));

        sc.close();
    }
}

import java.util.LinkedList;
import java.util.Scanner;

public class Solution {

    public static void main(String args[]) {
        Scanner Input = new Scanner(System.in);
        LinkedList<Character> L = new LinkedList();
        String S = Input.next();
        boolean T = true;
        for (int I = 0; I < S.length(); I++) {
            L.add(S.charAt(I));
        }
        String Ans = "";
        if (L.size() % 2 == 0) {
            while (!L.isEmpty()) {
                if (L.size() % 2 == 0) {
                    Ans += L.get((L.size() / 2) - 1);
                    L.remove((L.size() / 2) - 1);
                } else {
                    Ans += L.get(L.size() / 2);
                    L.remove(L.size() / 2);
                }
            }
        }
        if (L.size() % 2 == 1) {
            while (!L.isEmpty()) {
                Ans += L.get(L.size() / 2);
                L.remove(L.size() / 2);
            }
        }
        System.out.println(Ans);

    }

}

import java.util.Scanner;

public class TaskA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String encrypted = scanner.nextLine();
        char[] decrypted = new char[encrypted.length()];
        int first;
        if (encrypted.length() % 2 == 0)
            first = encrypted.length() / 2 - 1;
        else
            first = encrypted.length() / 2;
        if (encrypted.length() <= 2) {
            System.out.println(encrypted);
            return;
        } else if (encrypted.length() == 3) {
            System.out.print(encrypted.charAt(1));
            System.out.print(encrypted.charAt(2));
            System.out.print(encrypted.charAt(0));
            return;
        }

        decrypted[0] = encrypted.charAt(first);
        for (int i = 1, k = first + 1; i < encrypted.length() && k < encrypted.length(); i += 2, k++) {
            decrypted[i] = encrypted.charAt(k);
        }
        for (int i = 2, k = first - 1; i < encrypted.length() && k >= 0; i += 2, k-- ) {
            decrypted[i] = encrypted.charAt(k);
        }
        for (int i = 0; i < encrypted.length(); i++) {
            System.out.print(decrypted[i]);
        }
    }
}

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class Solution {

    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws IOException {
      String a=scanner.next();
      StringBuilder x=new
              StringBuilder();
      if(a.length()%2==0){
          int b=a.length()/2;
          for(int i=0;i<b;i++) {
              x.append(a.charAt(b - i-1));
              x.append(a.charAt(b + i));
          }
      }
      else {
          int b=a.length()/2;
          for(int i=0;i<=b;i++) {
              x.append(a.charAt(b - i));
              if(b+i+1<a.length())
               x.append(a.charAt(b + i+1));
          }
      }
      System.out.println(x);
    }
}

import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.StringTokenizer;
public class Main {

public static void A(BufferedReader br) throws IOException
{

	String s= br.readLine();
	StringTokenizer st=new StringTokenizer(s);
	String S=st.nextToken();
	String out="";
	if(S.length()>1)
	{
	int mid = S.length()/2 + (S.length())%2;
	out+= (char)S.charAt(mid-1);
	out+= (char)S.charAt( mid);
	//System.out.println(out);
	int j=mid-2;

	for(int i=mid +1 ;i<S.length();i++)
	{
		out+=(char)S.charAt(j);
		out+=(char)S.charAt(i);
		j-=1;
	}
	if(S.length()%2==1)
	{
		out+=(char)S.charAt(0);
	}
	}
	else
	{
		out=S;
	}
	System.out.println(out);
}

public static void main(String[]args) throws IOException
{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	A(br);

}

}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    public static void main(String args[] ) throws Exception {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT */
        Scanner in=new Scanner(System.in);
        String s= in.next();
        int c=s.length();
        int d=(c/2);
        int a=0;
        int b=1;
        if(c%2==0)
        {
            for(int i=0;i<c/2;i++)
            {
                System.out.print(s.charAt(d-b)+""+s.charAt(d+a));
                a++;
                b++;
            }
        }
        else
        {
            System.out.print(s.charAt(d));
            int x=1,z=1;
            for(int i=0;i<d;i++)
            {
                System.out.print(s.charAt(d+z)+""+s.charAt(d-x));
                z++;
                x++;
            }

        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {

        public int solve(int testNumber, InputReader in, PrintWriter out) {
			int n,i,j,k;
			char[] t;
			String s;
			s=in.next();
			n=s.length();

            t=new char[n];
			if(n%2==1){
			 i=0;
			j=n-1;
			k=n-1;
				while(true){

				if(i==j){
					t[k--]=s.charAt(i++);
					break;
				}

				t[k--]=s.charAt(i++);
				t[k--]=s.charAt(j--);

				}
			}
			else{
				   i=n-1;
				j=0;
				k=n-1;

				 while(j<i){

				t[k--]=s.charAt(i--);
				t[k--]=s.charAt(j++);
				}

			}
			for(int m=0;m<n;m++)
				out.print(t[m]);

			out.println();
return 0;
        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}

//package codeForces;

import java.util.Scanner;

public class CF1087A {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		int l = s.length();
		if(l<=2)
		{
			System.out.println(s);
		}
		else
		{
			int mid = 0;
			if(l%2==0)
			{
				mid = l/2-1;
			}
			else
			{
				mid = l/2;
			}
			String s1 =""+s.charAt(mid);
			int i = 1;
			while(mid-i>=0||mid+i<l)
			{
				if(mid+i<l){
					s1+=s.charAt(mid+i);
				}
				if(mid-i>=0){
					s1+=s.charAt(mid-i);
				}
				i++;
			}
			System.out.println(s1);
		}
		sc.close();
	}

}

/*
 * Date Created : 6/10/2020
 * Have A Good Day !
 */

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Arpit
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        ARightLeftCipher solver = new ARightLeftCipher();
        solver.solve(1, in, out);
        out.close();
    }

    static class ARightLeftCipher {
        public void solve(int testNumber, FastReader r, OutputWriter out) {
            char[] str = r.next().toCharArray();
            int i = (str.length - 1) >> 1;
            int j = i - 1;
            int chance = 0;
            out.print(str[i++]);
            int cnt = 1;
            while (cnt < str.length) {
                if (chance == 0) {
                    if (i < str.length && i >= 0) {
                        out.print(str[i++]);
                        cnt++;
                    }
                } else {
                    if (j >= 0 && j < str.length) {
                        out.print(str[j--]);
                        cnt++;
                    }
                }
                chance ^= 1;
            }
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                writer.print(objects[i]);
                if (i != objects.length - 1) writer.print(" ");
            }
        }

        public void close() {
            writer.close();
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.SpaceCharFilter filter;

        public FastReader(InputStream stream) {
            this.stream = stream;
        }

        public 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++];
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
import java.math.*;
public class Main extends Thread  {
    boolean[] prime;
    FastScanner sc;
    PrintWriter pw;
    long startTime = System.currentTimeMillis();
    final class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner() {
            try {
                br = new BufferedReader(new InputStreamReader(System.in));
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public long nlo() {
            return Long.parseLong(next());
        }

        public String next() {
            if (st.hasMoreTokens()) return st.nextToken();
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return st.nextToken();
        }

        public int ni() {
            return Integer.parseInt(next());
        }

        public String nli() {
            String line = "";
            if (st.hasMoreTokens()) line = st.nextToken();
            else try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            while (st.hasMoreTokens()) line += " " + st.nextToken();
            return line;
        }

        public double nd() {
            return Double.parseDouble(next());
        }
    }
    public Main(ThreadGroup t,Runnable r,String s,long d )
    {
        super(t,r,s,d);
    }
    public void run()
    {
        sc=new FastScanner();
        pw=new PrintWriter(System.out);
        solve();
        pw.flush();
        pw.close();
    }
    public static void main(String[] args)
    {
        new Main(null,null,"",1<<25).start();
    }

    /////////////------------------------------------//////////////
    ////////////------------------Main-Logic--------//////////////
    ///////////-------------------------------------//////////////
   public static int[] visit,col;
   public static ArrayList<Integer>[] adj;
   public static long mod,c1,c2;
    public void solve() {
     int t=1;
     while(t-->0)
     {
         char[] arr=sc.next().toCharArray();
         int n=arr.length;
         StringBuilder str=new StringBuilder("");
         int i=0,j=n-1;
         if(n%2==1)
         {str.append(arr[0]);
         i++;}
         while(j>i)
         {
             str.append(arr[j--]);
             str.append(arr[i++]);
         }
         pw.println(str.reverse());
     }
   }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args)
	{
		BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
		try {
			String entrada = read.readLine();
			String respuesta = "";
			char[] letras = entrada.toCharArray();
			char[] letrasRes = new char[letras.length];
			int i = (letras.length-1)/2;
			int j = 0;
			while(j < letras.length)
			{
				letrasRes[j] = letras[i];
				j++;
				if(i > (letras.length-1)/2)
				{
					i -= j;
				}
				else
				{
					i += j;
				}
			}
			respuesta = String.valueOf(letrasRes);
			System.out.println(respuesta);
			read.close();
		} catch (NumberFormatException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

//package prac;
import java.util.*;
//import java.math.*;
public class Main {
	static Scanner scn = new Scanner(System.in);
	public static void main(String[] args) {
		String t = scn.nextLine();
		System.out.println(stringinverse(t));

	}
	private static String stringinverse(String t) {
		if(t.length()==1||t.length()==0){
			return t;
		}
//		System.out.println(t.length());
		int mid = t.length()/2-1;
		if(t.length()%2==1)
			mid++;
		String ans = "";
		ans +=t.charAt(mid);
//		System.out.println(ans);
		for(int i = 1;mid-i>=0&&mid+i<t.length();i++){
			ans+=t.charAt(mid+i);
			ans+=t.charAt(mid-i);
		}
		if(ans.length()==t.length()-1){
			ans+=t.charAt(t.length()-1);
		}
		return ans;
	}
	private static int teamform(int[] arr) {
		Arrays.sort(arr);
		int ans = 0;
		for(int i = 0;i<arr.length;i+=2){
			ans+=Math.abs(arr[i]-arr[i+1]);
		}
		return ans;
	}

}

import java.util.*;
public class desc_y_ordenar_ascendentemente {
	public static void main(String[]args){
		Scanner leer=new Scanner(System.in);
		String cad=leer.next();
		String res="";
		if(cad.length()%2==0) {
			String n=cad.substring(0, cad.length()/2);
			String n2=cad.substring(cad.length()/2);
			StringBuilder k=new StringBuilder(n);
			String n1=k.reverse().toString();
			int a=0, b=0;
			for(int i=0; i<cad.length(); i++) {
				if(i%2==0) {
					res+=n1.charAt(a);
					a++;
				}
				else {
					res+=n2.charAt(b);
					b++;
				}
			}
			System.out.println(res);
		}
		else {
			String n=cad.substring(0, cad.length()/2+1);
			String n2=cad.substring(cad.length()/2+1);
			StringBuilder k=new StringBuilder(n);
			String n1=k.reverse().toString();
			int a=0, b=0;
			for(int i=0; i<cad.length(); i++) {
				if(i%2==0) {
					res+=n1.charAt(a);
					a++;
				}
				else {
					res+=n2.charAt(b);
					b++;
				}
			}
			System.out.println(res);
		}
	}
}

import java.util.Scanner;

public class First {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] n = sc.next().toCharArray();
        char[] res = new char[n.length];
        int midd = (n.length -1)/ 2;
        int even = 0;
        int odd = 1;
        for (int i = 0; i < n.length; i++) {
            if (i % 2 == 0) {
                res[i] = n[midd - even];
                midd -=even;
                even+=2;
            } else {
                res[i] = n[midd + odd];
                midd+=odd;
                odd+=2;
            }

        }
        System.out.println(new String(res));
    }
}

import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		String st=s.nextLine();
		String en="";
		char ch []=st.toCharArray();
		int r=ch.length-1;
		int l=0;
	//	System.out.println(l);
	//System.out.println(r);
	if(l==r)
	System.out.println(st);

	else if((r+1)%2==0)
	{
		while(l<r)
		{
		    en=st.charAt(r)+en;
		    en=st.charAt(l)+en;
		    l++;
		    r--;
		}
		System.out.println(en);
	}
	else
	{
	    while(l<=r)
		{
		    en=st.charAt(l)+en;
		    if(l!=r)
		    en=st.charAt(r)+en;

		    l++;
		    r--;
		}
		System.out.println(en);
	}

	}
}

/*# Date 23 Dec 2018;
# http://codeforces.com/contest/1087/problem/A  Right-Left Cipher
*/

import java.util.Scanner;

public class probA1087 {
    public static void main(String[] args)
    {
        //System.out.println("Please enter String");
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        char[] a=s1.toCharArray();
        int length = a.length;
        String result ="";
        int quotient;

        if(length %2 == 0) {
            quotient = (length / 2);
         }
        else {
            quotient = ((length + 1) / 2);
        }
            result = result + a[quotient-1];
            //System.out.println(result);
            int y=quotient-1;
            for (int x=quotient;x<length;x++){
                result = result + a[x];
                //System.out.println(result);

                y--;
                if (y>=0) {
                    result = result + a[y];
                    //System.out.println(result);
                }
            }

           //System.out.println("In Loop 2");

       System.out.println(result);
        //System.out.println(length);
    }
}

import java.util.Scanner;

public class rightLeft {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		String s=sc.next();
		String d="";
		if(s.length()%2==1)
		{
			d=d+s.charAt(s.length()/2);
			int a=s.length()/2;
			for(int i=a+1,j=a-1;i<s.length()&&j>=0;i++,j--)
			{
				d=d+s.charAt(i);
				d=d+s.charAt(j);
			}
		}
		else
		{
			int a=s.length()/2;
			for(int i=a-1,j=a;i>=0&&j<s.length();i--,j++)
			{
				d=d+s.charAt(i);
				d=d+s.charAt(j);
			}
		}
		System.out.println(d);
	}

}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Balloons
{
    public static void main (String[] args) throws java.lang.Exception
    {
    try {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String s=br.readLine();
        int n=s.length();
        if(n%2==0)
        {
           String k=s.substring(0,n-1);
          // System.out.print(k);
          Balloons.calc(k);

            System.out.print(s.substring(n-1,n));
        }else
        {
            Balloons.calc(s);
        }

    } catch(Exception e) {
    return;}
    }
    static void calc(String k)
    {
        char []ch=k.toCharArray();
           int m=ch.length;
           int half=m/2;
           char []ab=new char[(int)m];
           ab[0]=ch[(int)half];
           int j=1;
           for(int i=1;i<=half;i++)
           {

               ab[j]=ch[half+i];
               ab[j+1]=ch[half-i];
               j+=2;
              // System.out.println(ch[half+i]+" "+ch[half-i]);
              // System.out.println(ab[i]+" "+ab[i+1]);

           }
           for (int i=0;i<m ;i++ )
            System.out.print(ab[i]);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;

import java.util.*;

public class Soly
{
    static ArrayList<Integer>[] adjList;
    static boolean[] visited;
    static  int[] dis,par;
    static int V;

    static int h(int []a,int v){
        int s=0,e=a.length-1,ans=-1,mid=0;
        while (s<=e){
            mid=(s+e)>>1;
            if (a[mid]>=v){
                ans=mid;
                e=mid-1;
            }else s=mid+1;
        }
        return ans;
    }
    static void bfs(int s)
    {
        Queue<Integer> q = new LinkedList<Integer>();
        q.add(s);
        visited[s] = true;
        //dis[s]=0;
        par[s]=0;
        while(!q.isEmpty())
        {
            int u = q.remove();

            for(int v: adjList[u])
                if(!visited[v])
                {
                    visited[v] = true;
                    //dis[v]=dis[u]+1;
                    par[v]=u;
                    q.add(v);
                }
        }
    }
    static final int INF = Integer.MAX_VALUE;

    static void mergeSort(int[] a,int [] c, int b, int e)
    {
        if(b < e)
        {
            int q = (b + e) >>1;
            mergeSort(a,c, b, q);
            mergeSort(a, c,q + 1, e);
            merge(a,c, b, q, e);
        }
    }

    static void merge(int[] a,int[]c, int b, int mid, int e)
    {
        int n1 = mid - b + 1;
        int n2 = e - mid;
        int[] L = new int[n1+1], R = new int[n2+1];
        int[] L1 = new int[n1+1], R1 = new int[n2+1];

        for(int i = 0; i < n1; i++) {
            L[i] = a[b + i];
            L1[i] = c[b + i];
        }
        for(int i = 0; i < n2; i++)  {
            R[i] = a[mid + 1 + i];
            R1[i] = c[mid + 1 + i];
        }
        L[n1] = R[n2] = INF;

        for(int k = b, i = 0, j = 0; k <= e; k++)
            if(L[i] <= R[j]){
                a[k] = L[i];
                c[k] = L1[i++];
            }

            else
            {
                a[k] = R[j];
                c[k] = R1[j++];
            }
    }

    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(System.in);
        try (PrintWriter or = new PrintWriter(System.out)) {
                char[] a= in.next().toCharArray();
                StringBuilder s=new StringBuilder();
                if (a.length==1){
                    or.print(a[0]);return;
                }
                int y=a.length,f=y/2;
                int sss=0;
                if ((y&1)==0){
                s.append(a[f-1]);
                sss=f-1;
                }
                else{
                    s.append(a[f]);
                    sss=f;
                }

                int t=0;
                int i,p;
            for ( i = sss+1,p=sss-1; true; ) {
                    if ((t&1)==1){
                       if (p>=0)s.append(a[p--]);else break;
                    }else if (i<y)s.append(a[i++]);else break;
                    t++;
            }
            if (s.length()<y)s.append(a[y-1]);
            or.print(s);

        }

    }

    static class Scanner {

        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++) {
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec) {
                        f *= 10;
                    }
                }
            }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() throws IOException {
            return br.ready();
        }

    }

}
class coooo {
    int f;
    int t;

    public coooo(int f, int t) {
        this.f = f;
        this.t = t;
    }

}

import java.util.*;
public class Problem1087a {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        int n = s.length();
        if (n > 1) {
            if(n%2 == 0) {
                for (int i = 1; i < n/2+1; i++) {
                    System.out.print(s.charAt(n / 2 - i) + "" + s.charAt(n / 2 + i - 1));
                }
            }
            else {
                for(int i = 1; i < n/2+1; i++){
                    System.out.print(s.charAt(n/2+1-i) + "" + s.charAt(n/2+i));
                }
                System.out.print(s.charAt(0));
            }
        }
        else {
            System.out.print(s);
        }
    }
}

/*package whatever //do not write package name here */

import java.io.*;

public class GFG {
	public static void main (String[] args) throws IOException {
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		String s=in.readLine();
		int i=0,j=s.length()-1;
		String t="";
		if(s.length()%2==0){
		for(;i<s.length()/2;i++,j--)
		{
		    t=s.charAt(i)+""+s.charAt(j)+""+t;
		}}
		else{
		for(;i<s.length()/2;i++,j--)
		{
		    t=s.charAt(j)+""+s.charAt(i)+""+t;
		}}
		if(s.length()%2!=0)
		t=s.charAt(s.length()/2)+""+t;
		System.out.println(t);
	}
}

//import com.sun.org.apache.xpath.internal.operations.String;

//import com.sun.org.apache.xpath.internal.operations.String;

import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.LinkedBlockingDeque;

public class scratch_25 {
    // int count=0;
    //static long count=0;
    static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /**
         * call this method to initialize reader for InputStream
         */
        static void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        /**
         * get next word
         */
        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                //TODO add check for eof if necessary
                tokenizer = new StringTokenizer(
                        reader.readLine());
            }
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        static long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }

    public static class Graph{
        public static class Vertex{
            HashMap<Integer,Integer> nb= new HashMap<>();     // for neighbours of each vertex
        }

        public static HashMap<Integer,Vertex> vt;   // for vertices(all)

        public Graph(){
            vt= new HashMap<>();
        }

        public static int numVer(){
            return vt.size();
        }

        public static boolean contVer(int ver){
            return vt.containsKey(ver);
        }

        public static void addVer(int ver){
            Vertex v= new Vertex();
            vt.put(ver,v);
        }

        public static int numEdg(){
            int count=0;
            ArrayList<Integer> vrtc= new ArrayList<>(vt.keySet());
            for (int i = 0; i <vrtc.size() ; i++) {
                count+=(vt.get(vrtc.get(i))).nb.size();
            }
            return count/2;
        }

        public static boolean contEdg(int ver1, int ver2){
            if(vt.get(ver1)==null || vt.get(ver2)==null){
                return false;
            }

            Vertex v= vt.get(ver1);
            if(v.nb.containsKey(ver2)){
                return true;
            }
            return false;
        }

        public static void addEdge(int ver1, int ver2, int weight){
            if(!vt.containsKey(ver1) || !vt.containsKey(ver2)){
                return;
            }
            Vertex v1= vt.get(ver1);
            Vertex v2= vt.get(ver2);
            v1.nb.put(ver2,weight);                                 // if previously there is an edge, then this replaces that edge
            v2.nb.put(ver1,weight);
        }

        public static void delEdge(int ver1, int ver2){

            if(!vt.containsKey(ver1) || !vt.containsKey(ver2)){
                return;
            }

            vt.get(ver1).nb.remove(ver2);
            vt.get(ver2).nb.remove(ver1);

        }

        public static void delVer(int ver){
            if(!vt.containsKey(ver)){
                return;
            }
            Vertex v1= vt.get(ver);
            ArrayList<Integer> arr= new ArrayList<>(v1.nb.keySet());
            for (int i = 0; i <arr.size() ; i++) {
                int s= arr.get(i);
                vt.get(s).nb.remove(ver);
            }
            vt.remove(ver);
        }

        public class Pair{
            int vname;
            ArrayList<Integer> psf= new ArrayList<>();       // path so far
            int dis;
            int col;
        }

        public HashMap<Integer,Integer> bfs(int src){
            HashMap<Integer, Boolean> prcd= new HashMap<>();    // jo jo ho chuke hain unke liye

            HashMap<Integer, Integer> ans= new HashMap<>();

            LinkedList<Pair> queue= new LinkedList<>();      // for bfs queue

            Pair strtp= new Pair();

            strtp.vname= src;

            ArrayList<Integer> ar= new ArrayList<>();
            ar.add(src);

            strtp.psf= ar;
            strtp.dis=0;

            queue.addLast(strtp);

            while(!queue.isEmpty()){

                Pair rp =  queue.removeFirst();

                if(prcd.containsKey(rp.vname)){
                    continue;
                }
                prcd.put(rp.vname,true);
                ans.put(rp.vname,rp.dis);

//                if(contEdg(rp.vname,dst)){
//                    return true;
//                }

                Vertex a= vt.get(rp.vname);
                ArrayList<Integer> arr= new ArrayList<>(a.nb.keySet());
                for (int i = 0; i <arr.size() ; i++) {
                    int s= arr.get(i);
                    if(!prcd.containsKey(s)){
                        Pair np = new Pair();
                        np.vname= s;
                        np.dis+=rp.dis+a.nb.get(s);
                        np.psf.addAll(rp.psf);
                        np.psf.add(s);
//                        np.psf.add(s);
//                         np.psf= rp.psf+" "+s;
                        queue.addLast(np);
                    }

                }
            }
            return ans;

            //   return false;
        }

        public HashMap<Integer,Integer> dfs(int src){
            HashMap<Integer, Boolean> prcd= new HashMap<>();    // jo jo ho chuke hain unke liye

            HashMap<Integer, Integer> ans= new HashMap<>();

            LinkedList<Pair> stack= new LinkedList<>();      // for bfs queue

            Pair strtp= new Pair();

            strtp.vname= src;

            ArrayList<Integer> ar= new ArrayList<>();
            ar.add(src);

            strtp.psf= ar;
            strtp.dis=0;

            stack.addFirst(strtp);

            while(!stack.isEmpty()){

                Pair rp =  stack.removeFirst();

                if(prcd.containsKey(rp.vname)){
                    continue;
                }
                prcd.put(rp.vname,true);
                ans.put(rp.vname,rp.dis);

//                if(contEdg(rp.vname,dst)){
//                    return true;
//                }

                Vertex a= vt.get(rp.vname);
                ArrayList<Integer> arr= new ArrayList<>(a.nb.keySet());
                for (int i = 0; i <arr.size() ; i++) {
                    int s= arr.get(i);
                    if(!prcd.containsKey(s)){
                        Pair np = new Pair();
                        np.vname= s;
                        np.dis+=rp.dis+a.nb.get(s);
                        np.psf.addAll(rp.psf);
                        np.psf.add(s);
//                        np.psf.add(s);
//                         np.psf= rp.psf+" "+s;
                        stack.addFirst(np);
                    }

                }
            }
            return ans;

            //   return false;
        }

        public boolean isCycle(){
            HashMap<Integer, Boolean> prcd= new HashMap<>();    // jo jo ho chuke hain unke liye

            //   HashMap<Integer, Integer> ans= new HashMap<>();

            LinkedList<Pair> queue= new LinkedList<>();      // for bfs queue

            ArrayList<Integer> keys = new ArrayList<>(vt.keySet());
            for (int i = 0; i <keys.size(); i++) {
                int cur= keys.get(i);
                if(prcd.containsKey(cur)){
                    continue;
                }

                Pair sp = new Pair();
                sp.vname= cur;
                ArrayList<Integer> as= new ArrayList<>();
                as.add(cur);
                sp.psf= as;

                queue.addLast(sp);

                while(!queue.isEmpty()){

                    Pair rp= queue.removeFirst();
                    if(prcd.containsKey(rp.vname)){
                        return true;
                    }

                    prcd.put(rp.vname,true);

                    Vertex v1= vt.get(rp.vname);
                    ArrayList<Integer> nbrs= new ArrayList<>(v1.nb.keySet());
                    for (int j = 0; j <nbrs.size() ; j++) {
                        int u= nbrs.get(j);
                        Pair np= new Pair();
                        np.vname= u;
                        queue.addLast(np);
                    }
                }

            }
            return false;
        }

        public  ArrayList<ArrayList<Integer>> genConnctdComp(){
            HashMap<Integer, Boolean> prcd= new HashMap<>();    // jo jo ho chuke hain unke liye

            ArrayList<ArrayList<Integer>> ans= new ArrayList<>();

            //   HashMap<Integer, Integer> ans= new HashMap<>();

            LinkedList<Pair> queue= new LinkedList<>();      // for bfs queue

            //  int con=-1;

            ArrayList<Integer> keys = new ArrayList<>(vt.keySet());
            for (int i = 0; i <keys.size(); i++) {
                int cur= keys.get(i);
                if(prcd.containsKey(cur)){
                    //return true;
                    continue;
                }
                int count=0;
                ArrayList<Integer> fu= new ArrayList<>();
                fu.add(cur);

                Pair sp = new Pair();
                sp.vname= cur;
                ArrayList<Integer> as= new ArrayList<>();
                as.add(cur);
                sp.psf= as;

                queue.addLast(sp);

                while(!queue.isEmpty()){

                    Pair rp= queue.removeFirst();
                    if(prcd.containsKey(rp.vname)){
                        //return true;
                        continue;
                    }

                    prcd.put(rp.vname,true);
                    fu.add(rp.vname);

                    Vertex v1= vt.get(rp.vname);
                    ArrayList<Integer> nbrs= new ArrayList<>(v1.nb.keySet());
                    for (int j = 0; j <nbrs.size() ; j++) {
                        int u= nbrs.get(j);
                        if(!prcd.containsKey(u)){
                            count++;
                            Pair np= new Pair();
                            np.vname= u;
                            queue.addLast(np);
                        }
                    }}
                fu.add(count);
                ans.add(fu);

            }
            //return false;
            return ans;

        }

        public boolean isBip(int src){                       // only for connected graph

            HashMap<Integer,Integer> clr= new HashMap<>();
            // colors are 1 and -1

            LinkedList<Integer>q = new LinkedList<Integer>();
            clr.put(src,1);
            q.add(src);

            while(!q.isEmpty()){

                int u = q.getFirst();
                q.pop();

                ArrayList<Integer> arr= new ArrayList<>(vt.keySet());

                for (int i = 0; i <arr.size() ; ++i) {

                    int x= arr.get(i);

                    if(vt.get(u).nb.containsKey(x) && !clr.containsKey(x)){

                        if(clr.get(u)==1){
                            clr.put(x,-1);
                        }
                        else{
                            clr.put(x,1);
                        }
                        q.push(x);
                    }

                    else if(vt.get(u).nb.containsKey(x) && (clr.get(x).equals(clr.get(u)))){
                        return false;
                    }

                }
            }
            return true;
        }

        public static void printGr() {
            ArrayList<Integer> arr= new ArrayList<>(vt.keySet());
            for (int i = 0; i <arr.size() ; i++) {
                int ver= arr.get(i);
                Vertex v1= vt.get(ver);
                ArrayList<Integer> arr1= new ArrayList<>(v1.nb.keySet());
                for (int j = 0; j <arr1.size() ; j++) {
                    System.out.println(ver+"-"+arr1.get(j)+":"+v1.nb.get(arr1.get(j)));
                }

            }
        }
    }

    static class Cus implements Comparable<Cus>{
        int size;
        int mon;
        int num;
        public Cus(int size,int mon,int num){
            this.size=size;
            this.mon=mon;
            this.num=num;
        }
        @Override
        public int compareTo(Cus o){
            if(this.mon!=o.mon){
                return this.mon-o.mon;}

            else{
                return o.size-this.size;
            }

        }

    }

    static class Lamp implements Comparable<Lamp>{
        long start ;
        //  int cum;
        long end;
        public Lamp(long start,long end){
            this.start=start;
            //    this.cum=cum;
            this.end=end;
        }
        @Override
        public int compareTo(Lamp o){

            return (int)this.start-(int)o.start;

        }

    }

    static class Event implements Comparable<Event>{
        int value;
        int dist;
        public Event(int value,int dist){
            this.value=value;
            this.dist= dist;
        }

        @Override
        public int compareTo(Event o){

        if(this.dist!=o.dist){
          return this.dist-o.dist;}

        else{
            return this.value-o.value;
        }

          //  return (int)this.state-(int)o.state;

        }

    }
    static class Pair implements Comparable<Pair>{
        int num;
        //int cum;
        int fret;
        public Pair(int num,int fret){
            this.num=num;
            //  this.cum=cum;
            this.fret=fret;
        }
        @Override
        public int compareTo(Pair o){
           if(this.fret!=o.fret){
               return this.fret-o.fret;
           }
           else{
               return this.num-o.num;
           }

        }}

    public static class DisjointSet{
        HashMap<Integer,Node> mp= new HashMap<>();

        public static class Node{
            int data;
            Node parent;
            int rank;
        }

        public void create(int val){
            Node nn= new Node();
            nn.data=val;
            nn.parent=nn;
            nn.rank=0;
            mp.put(val,nn);
        }

        public int find(int val){

            return findn(mp.get(val)).data;

        }

        public Node findn(Node n){
            if(n==n.parent){
                return n;
            }
            Node rr= findn(n.parent);
            n.parent=rr;
            return rr;
        }

        public void union(int val1, int val2){                                                                               // can also be used to check cycles

            Node n1= findn(mp.get(val1));
            Node n2= findn(mp.get(val2));

            if(n1.data==n2.data) {
                return;
            }

            if(n1.rank<n2.rank){
                n1.parent=n2;
            }

            else if(n2.rank<n1.rank){
                n2.parent=n1;
            }

            else {
                n2.parent=n1;
                n1.rank++;
            }

        }
    }

    static int dp[][];
    static String table[]= new String[10];
    public static void main(String[] args)  throws IOException {
        Reader.init(System.in);
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
        String s= Reader.next();
        int x= s.length();
        if(x%2==0){
            char arr[]= new char[x];
            int p=0;
            for (int i = 0; i <x/2 ; i++) {
                arr[p]=s.charAt(x-1-i);
                p++;
                arr[p]=s.charAt(i);
                p++;
            }
            for (int i = x-1; i >=0 ; i--) {
                System.out.print(arr[i]);
            }
            System.out.println();
         //   System.out.println(Arrays.toString(arr));

        }
        else if(x%2!=0){
            char arr[]= new char[x];
            int p=0;
            for (int i = 0; i <=x/2 ; i++) {
                arr[p]=s.charAt(i);
                p++;
                if(p==x){
                    break;
                }
                arr[p]=s.charAt(x-1-i);
                p++;
            }
            for (int i = x-1; i >=0 ; i--) {
                System.out.print(arr[i]);
            }
            System.out.println();

        }

//        out.flush();
//        out.close();

        }

    static long power( long x, long y, long p)
    {
        // Initialize result
        long res = 1;

        // Update x if it is more
        // than or equal to p
        x = x % p;

        if (x == 0) return 0; // In case x is divisible by p;

        while (y > 0)
        {
            // If y is odd, multiply x
            // with result
            if((y & 1)==1)
                res = (res * x) % p;

            // y must be even now
            // y = y / 2
            y = y >> 1;
            x = (x * x) % p;
        }
        return res;
    }

    public static long ceil_div(long a, long b){
        return (a+b-1)/b;
    }

    static int countDivisibles(int A, int B, int M)
    {
        // Add 1 explicitly as A is divisible by M
        if (A % M == 0)
            return (B / M) - (A / M) + 1;

        // A is not divisible by M
        return (B / M) - (A / M);
    }

    public static void df(int x, int y,int n, int m, char[][]ar, int l){
        boolean done[][]= new boolean[n][m];
        int count=0;
        LinkedList<int[]> stk= new LinkedList<>();
        int a[]= {x,y};
        stk.addFirst(a);
        while(!stk.isEmpty() && count<l){
            //  count++;
            int b[]=stk.removeFirst();
            if( done[b[0]][b[1]]){
                continue;
            }
            count++;

            done[b[0]][b[1]]=true;
            ar[b[0]][b[1]]='@';
            int arr[][]={{1,0},{-1,0},{0,1},{0,-1}};
            for (int i = 0; i <arr.length ; i++) {
                if(!(b[0]+arr[i][0]>=n || b[1]+arr[i][1]>=m || b[0]+arr[i][0]<0 || b[1]+arr[i][1]<0 ||  ar[b[0]+arr[i][0]][b[1]+arr[i][1]]=='#')){
                    int r[]= {b[0]+arr[i][0], b[1]+arr[i][1]};
                    stk.addFirst(r);
                    // continue;

                }
            }}

        for (int i = 0; i <n ; i++) {
            for (int j = 0; j <m ; j++) {
                if(ar[i][j]=='.'){
                    System.out.print('X');
                }
                else if(ar[i][j]=='@'){
                    System.out.print('.');
                }
                else{
                    System.out.print(ar[i][j]);
                }
            }
            System.out.println();
        }

    }

    static long gcd(long a, long b)
    {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    static long gcd1(long a, long b)
    {

        // Everything divides 0
        if (a == 0)
            return b;
        if (b == 0)
            return a;

        // base case
        if (a == b)
            return a;

        // a is greater
        //count++;
        if (a > b){
            return gcd(a-b, b);

        }
        return gcd(a, b-a);
    }

    // method to return LCM of two numbers
    static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }

    // Driver method

    static int partition(long arr[],long arr1[], int low, int high)
    {
        long pivot = arr[high];
        int i = (low-1); // index of smaller element
        for (int j=low; j<high; j++)
        {
            // If current element is smaller than the pivot
            if (arr[j] < pivot)
            {
                i++;

                // swap arr[i] and arr[j]
                long temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                long temp1=arr1[i];
                arr1[i]=arr1[j];
                arr1[j]=temp1;

            }
        }

        // swap arr[i+1] and arr[high] (or pivot)
        long temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;
        long temp1= arr1[i+1];
        arr1[i+1]=arr1[high];
        arr1[high]= temp1;

        return i+1;
    }

    /* The main function that implements QuickSort()
      arr[] --> Array to be sorted,
      low  --> Starting index,
      high  --> Ending index */
    static void sort(long arr[],long arr1[], int low, int high)
    {
        if (low < high)
        {
            /* pi is partitioning index, arr[pi] is
              now at right place */
            int pi = partition(arr,arr1, low, high);

            // Recursively sort elements before
            // partition and after partition
            sort(arr,arr1, low, pi-1);
            sort(arr,arr1, pi+1, high);
        }
    }

    public static ArrayList<Integer> Sieve(int n) {
        boolean arr[]= new boolean [n+1];
        Arrays.fill(arr,true);
        arr[0]=false;
        arr[1]=false;
        for (int i = 2; i*i <=n ; i++) {
            if(arr[i]){
                for (int j = 2; j <=n/i ; j++) {
                    int u= i*j;
                    arr[u]=false;
                }}
        }
        ArrayList<Integer> ans= new ArrayList<>();
        for (int i = 0; i <n+1 ; i++) {
            if(arr[i]){
                ans.add(i);
            }
        }
        return ans;

    }

}

import java.util.*;

public class RightLeftCipher {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String encrypted = sc.next();
		String decrypted = "";
		int counterleft = 0;
		int counterright = encrypted.length()-1;
		boolean even = true;
		if (encrypted.length() % 2 == 1) {
			even = false;
		}
		while (counterleft != counterright) {
			if (even) {
				decrypted = encrypted.substring(counterright, counterright + 1) + decrypted;
				counterright --;
				even = false;
			}else {
				decrypted = encrypted.substring(counterleft, counterleft + 1) + decrypted;
				counterleft ++;
				even = true;
			}
		}
		decrypted = encrypted.substring(counterleft, counterleft + 1) + decrypted;
		System.out.println(decrypted);
	}

}

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        MyScanner in = new MyScanner(System.in);
        OutputWriter out = new OutputWriter(System.out);
        String s = in.next();
        StringBuilder b = new StringBuilder();
        int p0=0;
        int n = s.length();
        int p1=n-1;
        if (n%2==0)
        while (p0<=p1)
        {
            b.append(s.charAt(p1));
            p1--;
            if (p0<=p1)
            {
                b.append(s.charAt(p0));
                p0++;
            }
        }
        else
        {
            while (p0<=p1)
            {
                b.append(s.charAt(p0));
                p0++;

                if (p0<=p1)
                {
                    b.append(s.charAt(p1));
                    p1--;

                }
            }
        }
        String t =b.reverse().toString();
        out.printLine(t);
        out.flush();
    }
}
class MyScanner {

    StringTokenizer st;
    BufferedReader br;

    public MyScanner(InputStream s) {
        br = new BufferedReader(new InputStreamReader(s));
    }

    public MyScanner (FileReader f) {
        br = new BufferedReader(f);
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public String nextLine() throws IOException {
        return br.readLine();
    }

    public double nextDouble() throws IOException {
        String x = next();
        StringBuilder sb = new StringBuilder("0");
        double res = 0, f = 1;
        boolean dec = false, neg = false;
        int start = 0;
        if (x.charAt(0) == '-') {
            neg = true;
            start++;
        }
        for (int i = start; i < x.length(); i++)
            if (x.charAt(i) == '.') {
                res = Long.parseLong(sb.toString());
                sb = new StringBuilder("0");
                dec = true;
            } else {
                sb.append(x.charAt(i));
                if (dec)
                    f *= 10;
            }
        res += Long.parseLong(sb.toString()) / f;
        return res * (neg ? -1 : 1);
    }

    public boolean ready() throws IOException {
        return br.ready();
    }

    public boolean nextEmpty() throws IOException {
        String s = nextLine();
        st = new StringTokenizer(s);
        return s.isEmpty();
    }
}

class pair  implements Comparable
{
    int key;
    int value;
    int index;
    public pair(Object key, Object value,Object index) {

        this.key = (int)key;
        this.value=(int)value;
        this.index = (int)index;
    }
    @Override
    public int compareTo(Object o) {
        pair temp =(pair)o;
        return  value-temp.value;
    }
}
class Graph {

    int n;
    ArrayList<Integer>[] adjList;

    public Graph(int n) {
        this.n = n;
        adjList = new ArrayList[n];
        for (int i = 0; i < n; i++)
            adjList[i] = new ArrayList<>();
    }

}

class InputReader {

    private final InputStream stream;
    private final byte[] buf = new byte[8192];
    private int curChar, snumChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (snumChars == -1)
            throw new InputMismatchException();
        if (curChar >= snumChars) {
            curChar = 0;
            try {
                snumChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (snumChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        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 {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public int[] nextIntArray(int n) {
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    public String readString() {
        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 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();
    }

    public boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    public void flush() {
        writer.flush();
    }

}

import java.io.*;
import java.util.*;

public class Main {

    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static void main(String[] args) {
        FastReader sc = new FastReader();

        String input = sc.nextLine();
        int n = input.length();
        String result = "";

        int low = 0, high = n - 1;
        int mid = low + ((high - low)/2);
        result += input.charAt(mid);

        int p1 = mid + 1;
        int p2 = mid - 1;

        while(p1 < n || p2 >= 0){
            if(p1 < n){
                result += input.charAt(p1);
                p1++;
            }
            if(p2 >= 0){
                result += input.charAt(p2);
                p2--;
            }
        }

        System.out.println(result);
    }
}

//package dp;

import java.util.Scanner;

public class A1085 {
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		String str=s.next();
		if(str.length()<=2)
			System.out.println(str);
		else
		{
			int mid=-1;
			if(str.length()%2==0)
				mid=(str.length()/2)-1;
			else
				mid=str.length()/2;
			StringBuilder sb=new StringBuilder();
			sb.append(str.charAt(mid));
			for(int i=mid-1,j=mid+1;j<str.length();i--,j++)
			{
				sb.append(str.charAt(j));
				if(i>=0)
				sb.append(str.charAt(i));
			}
			System.out.println(sb.toString());
		}
	}
}

import java.util.*;
public class code1
{
  public static void main(String[] args)
  {
  		Scanner in = new Scanner(System.in);
  		//int n = in.nextInt();

  		//String s[] = new String[n];
       // int a[] = new int[m];
  		String s = in.next();
  		int cnt1 =0,cnt2=0;
  		int i,j;
  		int l = s.length();
  		int m=0;
  		if(l%2==0)
  			m = l/2-1;
  		else
  			m= l/2;
  		char r = s.charAt(m);
  		System.out.print(r);
  		for(i=1;i<l;++i)
  		{

			if((m+i)<l)
  			{
  			 System.out.print(s.charAt(m+i));
  			}
			if((m-i)>=0)
  			{
  			 System.out.print(s.charAt(m-i));
  			}

  		}

  }
}

import java.util.Arrays;
import java.util.Scanner;
public class Main {
	public static void main(String[] ar)
	{
	Scanner sc =new Scanner(System.in);
	String input=sc.nextLine();
    char[] arr=	input.toCharArray();
    char[] arr1=new char[arr.length];
    int k=arr.length-1;
    int m=0;
    if(arr.length%2==0)
    {
    	int l=arr.length-1;
    for(int i=0;i<arr.length/2;i++)
    {

    	arr1[l]=arr[k];
    	l=l-1;
    	k=k-1;
    	arr1[l]=arr[m];
    	l=l-1;
    	m=m+1;
    }}
    else
    {
    	int l=arr.length-1;
    	for(int i=0;i<arr.length/2;i++)
        {
        	arr1[l]=arr[m];
        	l=l-1;
        	m=m+1;
        	arr1[l]=arr[k];
        	l=l-1;
        	k=k-1;
        }
    	arr1[0]=arr[(arr.length/2)];
    }
    for(int j=0;j<arr1.length;j++)
    {
    	System.out.print(arr1[j]);
    }
	}
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

import static java.util.Collections.reverse;
import static java.util.Collections.sort;
import static jdk.nashorn.internal.objects.Global.print;

public class Fail {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        String s = in.next();
        String s1 = "";
        if(s.length()%2==0){
        for (int i = 0; i < s.length() / 2; i++) {
            s1 = Character.toString(s.charAt(s.length() - i - 1)) + s1;
            s1 = Character.toString(s.charAt(i)) + s1;

        }
            out.print(s1);
        }else{
            for (int i = 0; i < s.length() / 2; i++) {
                s1 = Character.toString(s.charAt(i)) + s1;
                s1 = Character.toString(s.charAt(s.length() - i - 1)) + s1;
               // out.print(s1);
            }
            s1 = Character.toString(s.charAt(s.length() / 2)) + s1;
            out.print(s1);
        }

       // out.print(s1);
    }

    static class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in);
        // in = new FastScanner(new FileInputStream("input.txt"));
        out = new PrintWriter(System.out);
        //  out = new PrintWriter(new FileOutputStream("output.txt"));
        solve();
        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Fail().run();

    }
}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.next();
StringBuilder output = new StringBuilder();
int left = 0, right = input.length();
boolean shouldReverse = (input.length() % 2 == 1);
for (int i = 0; i < input.length() ; i++) {
	boolean isEven = (i % 2 == 0);
	if (shouldReverse) isEven = !isEven;
	if (isEven) {
		right--;
		output.append(input.charAt(right));
	} else {
		output.append(input.charAt(left));
		left++;
	}
}
System.out.println(output.reverse().toString());
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) {
		Reader in = new Reader();
		String s  = in.next();
		int mid = (s.length()-1)/2;
		String ans = s.charAt(mid)+"";
		for(int i = 1; i<s.length()/2+1; i++) {
			if(mid+i<s.length()) ans += s.charAt(mid+i);
			if(mid-i>=0) ans += s.charAt(mid-i);
		}
		System.out.println(ans);
	}

	static class Reader {
		static BufferedReader br;
		static StringTokenizer st;

		public Reader() {
			this.br = new BufferedReader(new InputStreamReader(System.in));
		}

		public int nextInt() {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			;
			return Integer.parseInt(st.nextToken());
		}

		public double nextDouble() {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			;
			return Double.parseDouble(st.nextToken());
		}

		public Long nextLong() {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			;
			return Long.parseLong(st.nextToken());
		}

		public String next() {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			;
			return st.nextToken();
		}

		public static void readLine() {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
			}
			;
		}
	}
}

//package yahia;
import java.io.PrintWriter;
import java.util.*;public class Main {public static void main (String []args) {Scanner sc =new Scanner (System.in);PrintWriter pw =new PrintWriter(System.out);
String w =sc.next();char [] x =w.toCharArray();int a =x.length;String j ="";
if (a<=2) System.out.println(w);
else if (a%2==1) {
     j=x[a/2]+""+x[a/2+1];
     int i =(a/2-1);int s=a/2+2;
     while (i>=0||s<a) {
    	 j=j+x[i];--i;
    	 if (s<a) {
    		 j=j+x[s];++s;
    	 }
     }
     System.out.println(j);
}
else {
	j=j+x[a/2-1]+x[a/2];
	int i =(a-2)/2 -1;int s =a/2+1;
	while (i>0||s<a) {
		if (i>=0) {
			j=j+x[i];
			--i;
		}
		j=j+x[s];++s;
	}
	System.out.println(j);

}}}

import  java.io.*;
import  java.math.*;
import java.nio.Buffer;
import java.sql.SQLSyntaxErrorException;
import  java.util.*;
import  java.text.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        char[] str=cin.next().toCharArray();
        int len=str.length;
        int st=len/2-1;
        if(len%2==1){
            st=len/2;
        }
        if(len==1){
            System.out.println(str[0]);
            return;
        }
        System.out.print(str[st]);
        for(int i=1;i<=st;i++){

            System.out.print(str[st+i]);
            System.out.print(str[st-i]);
        }
        if(len%2==0){
            System.out.print(str[len-1]);
        }
        System.out.println();
    }
}

import java.util.*;

public class Main{
    public static void main(String [] args)
    {
        Scanner scan=new Scanner(System.in);
        String s=scan.next();
        String ans="";
        int l=s.length();
        int mid=(l-1)/2;
        int i;
        int p=0;
        for(i=0;i<l;i++)
        {
            ans=""+ans+s.charAt(mid);
            p++;
            if(i%2==0)
            {
                mid=mid+p;
            }
            else{
                mid=mid-p;
            }
        }
        System.out.println(ans);
    }

}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class RightLeftCipher {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
	public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
	public static StringTokenizer st;

	public static void main(String[] args) throws IOException {
		String t = nextString();
		String s = "";
		for (int i = 0; i < t.length(); i++)
			if ((t.length()+i) % 2 == 0)
				s = t.charAt(t.length()-1-i/2) + s;
			else
				s = t.charAt(i/2) + s;
		System.out.println(s);
	}

	public static String nextLine() throws IOException {
		return in.readLine();
	}

	public static String nextString() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(in.readLine());
		return st.nextToken();
	}

	public static int nextInt() throws IOException {
		return Integer.parseInt(nextString());
	}

	public static long nextLong() throws IOException {
		return Long.parseLong(nextString());
	}

	public static int[] intArray(int n) throws IOException {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	public static int[][] intArray(int n, int m) throws IOException {
		int[][] a = new int[n][m];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < m; j++)
				a[i][j] = nextInt();
		return a;
	}

	public static long[] longArray(int n) throws IOException {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}
}

/*# Date 23 Dec 2018;
# http://codeforces.com/contest/1087/problem/A  Right-Left Cipher
*/

import java.util.Scanner;

public class probA1087 {
    public static void main(String[] args)
    {
        //System.out.println("Please enter String");
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        char[] a=s1.toCharArray();
        int length = a.length;
        String result ="";
        int quotient;

        if(length %2 == 0) {
            quotient = (length / 2);
         }
        else {
            quotient = ((length + 1) / 2);
        }
            result = result + a[quotient-1];
            //System.out.println(result);
            int y=quotient-1;
            for (int x=quotient;x<length;x++){
                result = result + a[x];
                //System.out.println(result);

                y--;
                if (y>=0) {
                    result = result + a[y];
                    //System.out.println(result);
                }
            }

           //System.out.println("In Loop 2");

       System.out.println(result);
        //System.out.println(length);
    }
}

import java.util.*;
public class A{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String s = scan.next();
		int n = s.length();
		int i = 0,j = n-1;
		StringBuilder ans =  new StringBuilder();
		while(i < j)
		{
			if(n%2 == 1)
			{
				ans.append(s.charAt(i));
				ans.append(s.charAt(j));
			}
			else
			{
				ans.append(s.charAt(j));
				ans.append(s.charAt(i));
			}

			i++;j--;
		}
		if(n%2 == 1)
			ans.append(s.charAt(i));
		System.out.println(ans.reverse());
	}
}

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    String k=s.next();
    int n=k.length();
    if(n%2==0)
    {
      String a=k.substring(0, n/2);
      String b=k.substring(n/2);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-1-i));
        System.out.print(b.charAt(i));
      }
    }
    else
    {
      String a=k.substring(0, n/2 +1);
      String b=k.substring(n/2 +1);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-i));
        System.out.print(b.charAt(i));
      }
      System.out.print(a.charAt(0));
    }
  }
}

import java.io.*;
import java.util.*;

public class cf123A{
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = br.readLine();

		if(s.length()<=2) {
			System.out.println(s);
			return;
		}

		int l = s.length()-1;
		int mid = l/2;
		int i=mid-1;
		int j=mid+1;
		System.out.print(s.charAt(mid));
		while(i>=0 && j<s.length()) {
			System.out.print(s.charAt(j));
			j++;
			System.out.print(s.charAt(i));
			i--;
		}

		if(j<s.length()) {
			System.out.print(s.charAt(j));
		}

	}
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String s=in.next();
        String stringFinal="";
       if(s.length()%2==0){
           int k=s.length()/2;
           stringFinal+=s.charAt(k-1);

           for (int i = 1; i <k ; i++) {
               stringFinal+=s.charAt(k+i-1);
               stringFinal+=s.charAt(k-i-1);
           }
           stringFinal+=s.charAt(2*k-1);
       }else {
           int k=(s.length()-1)/2;
           stringFinal+=s.charAt(k);

           for (int i = 1; i <k+1 ; i++) {
               stringFinal+=s.charAt(k+i);
               stringFinal+=s.charAt(k-i);
           }
           //stringFinal+=s.charAt(2*k-1);
       }
        System.out.println(stringFinal);
    }
}

import java.util.*;

public class main
{
       public static void main(String args[])
       {
              Scanner sc=new Scanner(System.in);
              String s=sc.next();
              String st="";
              String x="";
              String y="";
              int pos=0;
              if(s.length()%2==0)
              {   pos=s.length()/2;
                     for(int i=pos-1;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
              }

              else
              {
                     pos=(s.length()/2);
                     for(int i=pos;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos+1;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
                     if(x.length()>y.length())
                     {
                            st+=x.charAt(x.length()-1);
                     }
                     else
                     {
                            st+=y.charAt(y.length()-1);
                     }

              }
              System.out.println(st);
       }
}

import java.util.Scanner;

public class main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String word = in.nextLine();

		int length = word.length();
		char[] arrInput = word.toCharArray();

		int r, l = 0;
		if (length % 2 == 0) {
			r = length / 2 - 1;
			l = r;
		} else {
			r = length / 2;
			l = r;
		}
		char [] wordOuput = new char[length];
		wordOuput[0] = arrInput[r];
		for (int i = 1; i < length; i++) {
			if(i%2==0){
				l--;
				wordOuput[i] = arrInput[l];
			}else{
				r++;
				wordOuput[i] = arrInput[r];

			}
		}
		for (int i = 0; i < length; i++) {
			System.out.print(wordOuput[i]);
		}
	}

}

import java.util.*;
import java.io.*;

public class Solution {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		char[] s = scan.next().toCharArray();
        int n = s.length,l = 0, r = n - 1;
        boolean bool = n % 2 == 0;

        StringBuilder sb = new StringBuilder();
        while (l <= r){
            if(bool){
                sb.append(s[r]);
                r--;
            }
            else{
                sb.append(s[l]);
                l++;
            }
            bool = !bool;
        }
        System.out.println(sb.reverse().toString());
		scan.close();
	}
}

import java.util.*;
public class desc_y_ordenar_ascendentemente {
	public static void main(String[]args){
		Scanner leer=new Scanner(System.in);
		String cad=leer.next();
		String res="";
		if(cad.length()%2==0) {
			String n=cad.substring(0, cad.length()/2);
			String n2=cad.substring(cad.length()/2);
			StringBuilder k=new StringBuilder(n);
			String n1=k.reverse().toString();
			int a=0, b=0;
			for(int i=0; i<cad.length(); i++) {
				if(i%2==0) {
					res+=n1.charAt(a);
					a++;
				}
				else {
					res+=n2.charAt(b);
					b++;
				}
			}
			System.out.println(res);
		}
		else {
			String n=cad.substring(0, cad.length()/2+1);
			String n2=cad.substring(cad.length()/2+1);
			StringBuilder k=new StringBuilder(n);
			String n1=k.reverse().toString();
			int a=0, b=0;
			for(int i=0; i<cad.length(); i++) {
				if(i%2==0) {
					res+=n1.charAt(a);
					a++;
				}
				else {
					res+=n2.charAt(b);
					b++;
				}
			}
			System.out.println(res);
		}
	}
}

import java.io.*;    //PrintWriter
import java.math.*;  //BigInteger, BigDecimal
import java.util.*;  //StringTokenizer, ArrayList

public class R528_Div2_A
{
	FastReader in;
	PrintWriter out;

	public static void main(String[] args)  {
		new R528_Div2_A().run();
	}

	void run()
	{
		in = new FastReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	void solve()
	{
		String s = in.next();
		String s2 = "";
		int n = s.length();
		if (n % 2 == 0) {
			int st = 0, en = n-1;
			for (int i = 0; i < n / 2; i++) {
				s2 = "" + s.charAt(st) + s.charAt(en) + s2;
				st++; en--;
			}
		}
		else {
			s2 += s.charAt(n/2);
			for (int i = 1; i <= n/2; i++) {
				s2 += s.charAt(n/2 + i);
				s2 += s.charAt(n/2 - i);
			}
		}
		out.println(s2);
	}

	//-----------------------------------------------------
	void runWithFiles() {
		in = new FastReader(new File("input.txt"));
		try {
			out = new PrintWriter(new File("output.txt"));
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		solve();
		out.close();
	}

	class FastReader
	{
	    BufferedReader br;
	    StringTokenizer tokenizer;

	    public FastReader(InputStream stream)
	    {
	        br = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }
		public FastReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
				tokenizer = null;
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

	    private String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens())
	            try {
	            	tokenizer = new StringTokenizer(br.readLine());
	            }
	            catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        return tokenizer.nextToken();
	    }
		public String nextLine() {
			try	{
				return br.readLine();
			}
			catch(Exception e) {
				throw(new RuntimeException());
			}
		}

	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	    BigDecimal nextBigDecimal() {
	        return new BigDecimal(next());
	    }
	}
}

import java.util.Scanner;

public class First {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[] n = sc.next().toCharArray();
        char[] res = new char[n.length];
        int midd = (n.length -1)/ 2;
        int even = 0;
        int odd = 1;
        for (int i = 0; i < n.length; i++) {
            if (i % 2 == 0) {
                res[i] = n[midd - even];
                midd -=even;
                even+=2;
            } else {
                res[i] = n[midd + odd];
                midd+=odd;
                odd+=2;
            }

        }
        System.out.println(new String(res));
    }
}

import java.util.*;

public class stringss {
public static void main(String args[]) {
Scanner sc= new Scanner(System.in);
String s=sc.next();
String a="ncteho";
int k=s.length();
if(k==1)
{System.out.println(s);
System. exit(0);
}
if(k%2==0)
{
k=k/2;
k=k-1;
}
else k=k/2;
String temp="";
char[] result=s.toCharArray();
temp=temp+result[k];
int i,j;
for(i=k+1,j=k-1; i<=s.length() && j>=0;i++,j--)
{temp=temp+result[i];
temp=temp+result[j];
}
if(s.length()%2==0)
{
temp=temp+result[s.length()-1];
}
System.out.println(temp);
}

}

import java.util.*;
public class file{
public static void main(String[] args){
Scanner scan  = new Scanner(System.in);
String str =scan.nextLine();
int len =str.length();
if(len <=2) {
System.out.println(str);
}else if(len%2 != 0) {

int c=len/2;
int l=c-1;
int r=c+1;
String ans =""+str.charAt(c);
for(int i=0 ;i<(len/2) ;i++){
if(r <len){
ans+=str.charAt(r);
r++;
}

if(l>=0){
ans+=str.charAt(l);
l--;
}

}
System.out.println(ans);

}else {
int c=len/2 -1;
int l=c-1;
int r=c+1;
String ans =""+str.charAt(c);
for(int i=0 ;i<(len/2) ;i++){
if(r <len){
ans+=str.charAt(r);
r++;
}

if(l>=0){
ans+=str.charAt(l);
l--;
}

}
System.out.println(ans);
}
}
}

import java.io.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.StringTokenizer;
public class Main {

public static void A(BufferedReader br) throws IOException
{

	String s= br.readLine();
	StringTokenizer st=new StringTokenizer(s);
	String S=st.nextToken();
	String out="";
	if(S.length()>1)
	{
	int mid = S.length()/2 + (S.length())%2;
	out+= (char)S.charAt(mid-1);
	out+= (char)S.charAt( mid);
	//System.out.println(out);
	int j=mid-2;

	for(int i=mid +1 ;i<S.length();i++)
	{
		out+=(char)S.charAt(j);
		out+=(char)S.charAt(i);
		j-=1;
	}
	if(S.length()%2==1)
	{
		out+=(char)S.charAt(0);
	}
	}
	else
	{
		out=S;
	}
	System.out.println(out);
}

public static void main(String[]args) throws IOException
{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	A(br);

}

}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays;
import java.math.BigInteger;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
     public static void main (String[] args) throws java.lang.Exception
     {
     	Scanner in =new Scanner(System.in);
		int t=1,i,j,l,n,m,k=0,p=0,h=0;
		String s="",st="";
		long x=0;
		for(i=0;i<t;i++)
		{
		     s=in.next();
		     n=s.length();
		     char c[]=s.toCharArray();
		     if(n%2==0)
		     {
		          st+=c[n/2-1];
		          for(j=n/2,k=n/2-2;j<n-1;j++,k--)
		          {
		               st+=c[j];
		               st+=c[k];
		          }
		          st+=c[n-1];
		     }
		     else
		     {
		          st+=c[n/2];
		          for(j=n/2+1,k=n/2-1;j<n;j++,k--)
		          {
		               st+=c[j];
		               st+=c[k];
		          }
		     }
		     System.out.println(st);
		}
	}
}

import java.util.*;

public class Solution {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		StringBuilder s = new StringBuilder(scan.nextLine());
		StringBuilder result = new StringBuilder();
		boolean fromEnd = (s.length()%2 == 0);
		int i;
		while(s.length() > 0) {
			i = fromEnd ? s.length()-1 : 0;
			char ch = s.charAt(i);
			result.insert(0, ch);
			s.deleteCharAt(i);
			fromEnd = !fromEnd;
		}
		System.out.println(result);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author @Ziklon
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    ARightLeftCipher solver = new ARightLeftCipher();
    solver.solve(1, in, out);
    out.close();
  }

  static class ARightLeftCipher {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      String s = in.readString();
      StringBuilder sb = new StringBuilder();

      int low = 0, hih = s.length() - 1;
      int size = s.length();

      while (hih > low) {
        if (size % 2 == 0) {
          sb.append(s.charAt(hih--));
          sb.append(s.charAt(low++));
        } else {
          sb.append(s.charAt(low++));
          sb.append(s.charAt(hih--));
        }
      }
      if (hih == low) sb.append(s.charAt(hih));
      out.printLine(sb.reverse());
    }
  }

  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; i++) {
        if (i != 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void printLine(Object... objects) {
      print(objects);
      writer.println();
    }

    public void close() {
      writer.close();
    }
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private InputReader.SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public 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++];
    }

    public String readString() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      StringBuilder res = new StringBuilder();
      do {
        if (Character.isValidCodePoint(c)) {
          res.appendCodePoint(c);
        }
        c = read();
      } while (!isSpaceChar(c));
      return res.toString();
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);
    }
  }
}

import java.util.Scanner;

public class A {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String string = in.nextLine();
        int n = string.length();

        if (n == 1 || n == 2) {
            System.out.println(string);
        } else {
            if (n % 2 == 0) {
                int half = n / 2 - 1;
                int next = half + 1;
                System.out.print(string.charAt(half) + "" + string.charAt(next));

                for (int i = 0; i < n / 2 - 1; i++) {
                    System.out.print(string.charAt(--half) + "" + string.charAt(++next));
                }
            } else {
                int half = n / 2;
                int next = half + 1;
                System.out.print(string.charAt(half) + "" + string.charAt(next));

                for (int i = 0; i < n / 2 - 1; i++) {
                    System.out.print(string.charAt(--half) + "" + string.charAt(++next));
                }

                System.out.print(string.charAt(0));
            }
        }

        in.close();
    }
}

import java.util.Scanner;
import java.util.Stack;

public class pre42
{
    public static void main(String args[])
    {
        Scanner obj = new Scanner(System.in);
        String str = obj.next();
        int i=0,j=str.length()-1;
        Stack<Character> stack = new Stack<>();
        if(str.length()%2==0)
        {
            while (j>i)
            {
                stack.push(str.charAt(j));
                j--;
                stack.push(str.charAt(i));
                i++;
            }
        }
        else
        {
            while (j!=i)
            {
                stack.push(str.charAt(i));
                i++;
                stack.push(str.charAt(j));
                j--;
            }
            stack.push(str.charAt(j));
        }
        while (!stack.isEmpty())
            System.out.print(stack.pop());
    }
}

import  java.io.*;
import  java.math.*;
import java.nio.Buffer;
import java.sql.SQLSyntaxErrorException;
import  java.util.*;
import  java.text.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        char[] str=cin.next().toCharArray();
        int len=str.length;
        int st=len/2-1;
        if(len%2==1){
            st=len/2;
        }
        if(len==1){
            System.out.println(str[0]);
            return;
        }
        System.out.print(str[st]);
        for(int i=1;i<=st;i++){

            System.out.print(str[st+i]);
            System.out.print(str[st-i]);
        }
        if(len%2==0){
            System.out.print(str[len-1]);
        }
        System.out.println();
    }
}

import java.util.Scanner;

public class RightLeftCipher {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String str = in.next();
        String new_str = "";
        if (str.length() % 2 == 1){
            int start = str.length()/2;
            int left = start, rigth = start;
            new_str += str.charAt(start);
            for (int i = 0; i < str.length()-1; i++){
                if (i % 2 == 0){
                    rigth++;
                    new_str += str.charAt(rigth);
                }
                else{
                    left--;
                    new_str += str.charAt(left);
                }
            }
            System.out.println(new_str);
            return;
        }
        int start = str.length()/2-1;
        int left = start, rigth = start;
        new_str += str.charAt(start);
        for (int i = 1; i < str.length(); i++){
            if (i % 2 == 1){
                rigth++;
                new_str += str.charAt(rigth);
            }
            else{
                left--;
                new_str += str.charAt(left);
            }
        }
        System.out.println(new_str);
    }

}

import java.util.Scanner;

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

		String t = sc.next();
		System.out.println(solve(t));

		sc.close();
	}

	static String solve(String t) {
		int leftIndex = 0;
		int rightIndex = t.length() - 1;
		boolean leftOrRight = t.length() % 2 != 0;
		StringBuilder result = new StringBuilder();
		for (int i = 0; i < t.length(); i++) {
			if (leftOrRight) {
				result.append(t.charAt(leftIndex));
				leftIndex++;
			} else {
				result.append(t.charAt(rightIndex));
				rightIndex--;
			}

			leftOrRight = !leftOrRight;
		}
		return result.reverse().toString();
	}
}

import java.util.*;
public class leftright
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int l = s.length();
        String st = "";
        if(l==1)
            System.out.println(s);
        else if((l-1)%2!=0)
        {
            boolean b = false;
            int c = 0;
            while(b==false)
            {
                char ch = s.charAt(l-c-1);
                st = ch + st;
                ch = s.charAt(c);
                st = ch + st;
                c++;
                if(c == l/2)
                    b = true;
            }
            System.out.println(st);
        }
        else
        {
            boolean b = false;
            int c = 0;
            while(b==false)
            {
                char ch = s.charAt(c);
                st = ch + st;
                ch = s.charAt(l-c-1);
                st = ch + st;
                c++;
                if(c == (l-1)/2 || c==l)
                    b = true;
            }
            if(c<l)
            st = s.charAt(c) + st;
            System.out.println(st);
        }
    }
}

import java.io.*;
import java.util.*;

public class byo {
	static long gcd(long a, long b) {

		if (b == 0)
			return a;
		return gcd(b, a % b);
	}
	static char addc(char a,char b) {
		int x=Integer.parseInt(a+"");
		int y=Integer.parseInt(b+"");
		int z=x+y;
		if(z<=9) {
			return (char)('0'+z);
		}
		z=z%10;
		return (char)('0'+z);
	}
	static String add(String a,String b) {
		String r="";
		if(a.length()>=b.length()) {
			int ai=a.length()-1;int bi=b.length()-1;
			while(bi>=0) {
				char c=addc(a.charAt(ai),b.charAt(bi));
				ai--;bi--;

				r=c+r;
			}
			while(ai>=0) {
				r=a.charAt(ai)+r;ai--;
			}
		}
		else {
			int ai=a.length()-1;int bi=b.length()-1;
			while(ai>=0) {
				char c=addc(a.charAt(ai),b.charAt(bi));
				ai--;bi--;

				r=c+r;
			}
			while(bi>=0) {
				r=b.charAt(bi)+r;bi--;
			}
		}

		String f="";
		int o=0;
		while(o<r.length() && r.charAt(o)=='0') {
			o++;
		}
		while(o<r.length()) {
			f+=r.charAt(o);o++;
		}
		if(f.length()==0)return "0";
		return f;
	}
	static long sub(String b,boolean flag) {
		StringBuilder re=new StringBuilder();
		for(int i=0;i<b.length();i++) {
			if(b.charAt(i)=='0') {
				if(re.length()==0)continue;
				re.append('0');
			}
			else {
				re.append((char)('9'+'1'-b.charAt(i)));
			}
		}
		if(re.length()==0) {
			return 0;
		}
		if(flag) {
			StringBuilder o=new StringBuilder();
			for(int i=0;i<re.length();i++) {
				if(re.charAt(i)=='0') {
					o.append('9');
				}
				else
					if(re.charAt(i)=='1' && o.length()==0) {
						continue;
					}
					else
						o.append((char)(re.charAt(i)-1));
			}
			if(o.length()==0) {
				return 0;
			}
			return Long.parseLong(o.toString());
		}
		return Long.parseLong(re.toString());
	}
	static int m;static int n;
	static int[]dx= {0,1,-1,0};
	static int[]dy= {1,0,0,-1};
	static int[][]in;
	static boolean isv(int i,int j) {
		if(i>=0 && i<n && j>=0 && j<m)return true;
		return false;
	}
    public static void main(String[] args) throws Exception{
        MScanner sc = new MScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        String s=sc.nextLine();
        int i=(s.length()-1)/2;
        pw.print(s.charAt(i));int x=1;
        while(i+x<s.length() || i-x>=s.length()) {
        	if(i+x>=s.length()) {
        		pw.print(s.charAt(i-x));
        	}
        	else {
        		if(i-x<0) {
        			pw.print(s.charAt(i+x));
        		}
        		else {
        			pw.print(s.charAt(i+x)+""+s.charAt(i-x));
        		}
        	}
        	x++;
        }
        pw.flush();
    }
    static int INF=(int)1e9;

    static LinkedList<Edge>adjList[];
    static int[] dist = new int[1000000];
    static int dijkstra(int S, int T)	//O(E log E)
	{
		Arrays.fill(dist, INF);
		PriorityQueue<Edge> pq = new PriorityQueue<Edge>();
		dist[S] = 0;
		pq.add(new Edge(S, 0));						//may add more in case of MSSP (Mult-Source)
		while(!pq.isEmpty())
		{
			Edge cur = pq.remove();
			if(cur.node == T)						//remove if all computations are needed
				return dist[T];
			if(cur.cost > dist[cur.node])			//lazy deletion
				continue;
			for(Edge nxt: adjList[cur.node])
				if(cur.cost + nxt.cost < dist[nxt.node])
					pq.add(new Edge(nxt.node, dist[nxt.node] = cur.cost + nxt.cost ));
		}
		return -1;
	}
    static class tri implements Comparable<tri>{
    	int x;int y;
    	tri(int a,int b){
    		x=a;y=b;
    	}
		@Override
		public int compareTo(tri o) {
			if(x!=o.x) {
				return x-o.x;
			}
				return y-o.y;

		}
		public String toString() {
			return "("+x+" "+y+")";
		}
    }
    static class Edge implements Comparable<Edge>{
    	int node;int cost;
    	Edge(int a,int b){
    		node=a;cost=b;
    	}
		@Override
		public int compareTo(Edge o) {
			if(cost!=o.cost) {
				return cost-o.cost;
			}
				return node-o.node;

		}
		public String toString() {
			return "("+node+" "+cost+")";
		}
    }
    static class MScanner {
        StringTokenizer st;
        BufferedReader br;

        public MScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        public String nextLine() throws IOException {
            return br.readLine();
        }

        public double nextDouble() throws IOException {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() throws IOException {
            return br.ready();
        }

    }
}

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    String k=s.next();
    int n=k.length();
    if(n%2==0)
    {
      String a=k.substring(0, n/2);
      String b=k.substring(n/2);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-1-i));
        System.out.print(b.charAt(i));
      }
    }
    else
    {
      String a=k.substring(0, n/2 +1);
      String b=k.substring(n/2 +1);
      System.out.println(b);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-i));
        System.out.print(b.charAt(i));
      }
      System.out.print(a.charAt(0));
    }
  }
}

import java.util.*;

public class main
{
       public static void main(String args[])
       {
              Scanner sc=new Scanner(System.in);
              String s=sc.next();
              String st="";
              String x="";
              String y="";
              int pos=0;
              if(s.length()%2==0)
              {   pos=s.length()/2;
                     for(int i=pos-1;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
              }

              else
              {
                     pos=(s.length()/2);
                     for(int i=pos;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos+1;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
                     if(x.length()>y.length())
                     {
                            st+=x.charAt(x.length()-1);
                     }
                     else
                     {
                            st+=y.charAt(y.length()-1);
                     }

              }
              System.out.println("String is: "+st);
       }
}

import java.util.*;
public class RLC{
	public static void main(String args[])
	{
		Scanner in = new Scanner(System.in);
		String s = in.nextLine();
		String o = new String();
		//techno
		//ncteho
		for(int i = 0 ; i < s.length()/2; i++)
		{
			if(s.length()%2 == 0)
			{
					o = s.charAt(s.length() - i - 1) + o;
					o = s.charAt(i) + o;
			}
			else
			{
				o = s.charAt(i) + o;
				o = s.charAt(s.length() - i - 1) + o;
			}

		}
		System.out.println(o);
	}
}

/*package whatever //do not write package name here */

import java.io.*;

public class GFG {
	public static void main (String[] args) throws IOException {
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		String s=in.readLine();
		int i=0,j=s.length()-1;
		String t="";
		for(;i<s.length()/2;i++,j--)
		{
		    t=s.charAt(i)+""+s.charAt(j)+""+t;
		}
		if(s.length()%2!=0)
		t=s.charAt(s.length()/2)+""+t;
		System.out.println(t);
	}
}

import java.io.*;
import java.util.*;

public class Pascal {

    static PrintWriter out = new PrintWriter(System.out);
    static BufferedReader br;
    static StringTokenizer st;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String s = next();
        if (s.length() % 2 == 0){
            out.print(s.charAt(s.length() / 2 - 1));
            for (int i = 1; i < s.length() / 2; i++) {
                out.print(s.charAt(s.length() / 2 - 1 + i));
                out.print(s.charAt(s.length() / 2 - 1 - i));
            }
            out.print(s.charAt(s.length() - 1));
        }
        else {
            out.print(s.charAt(s.length() / 2));
            for (int i = 1; i < s.length() / 2; i++) {
                out.print(s.charAt(s.length() / 2 + i));
                out.print(s.charAt(s.length() / 2 - i));
            }
            out.print(s.charAt(0));
        }
        out.close();
    }

    static int nextInt() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }

    static long nextLong() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }

    static String next() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}

	import java.util.*;
	import java.lang.*;
	import java.text.DecimalFormat;
	import java.text.NumberFormat;
	import java.io.*;
	public class Solution {

		static class FastReader {
	        BufferedReader br;
	        StringTokenizer st;

	        public FastReader() {
	            br = new BufferedReader(new
	                    InputStreamReader(System.in));
	        }

	        static long gcd(long a, long b){
			      if (b == 0)
			        return a;
			      return gcd(b, a % b);
			}

	        String next() {
	            while (st == null || !st.hasMoreElements()) {
	                try{
	                    st = new StringTokenizer(br.readLine());
	                }
	                catch (IOException  e) {
	                    e.printStackTrace();
	                }
	            }
	            return st.nextToken();
	        }
	        int nextInt() {
	            return Integer.parseInt(next());
	        }
	        long nextLong() {
	            return Long.parseLong(next());
	        }
		public int[] readIntArray(int n) {
				int[] arr = new int[n];
				for(int i=0; i<n; ++i)
					arr[i]=nextInt();
				return arr;
			}

	        double nextDouble() {
	            return Double.parseDouble(next());
	        }

	        String nextLine() {
	            String str = "";
	            try{
	                str = br.readLine();
	            }
	            catch (IOException e) {
	                e.printStackTrace();
	            }
	            return str;
	        }
	    }
		static void solve(String str, int n) {
			if(str.length() == 1 || str.length() == 2) {
	        	System.out.println(str);
	        	return;
	        }
	        char[] arr = str.toCharArray();

	        StringBuilder sb = new StringBuilder();
	        int mid = n/2;
	        sb.append(str.charAt(mid-1));
	        int i = mid - 1, j = mid + 1;
	       while(i >= 1 || j  <= n) {
	    	   if(j <= n) {
	    	   sb.append(str.charAt(j-1));
	    	   }
	    	  if(i >= 1) {
	    	   sb.append(str.charAt(i-1));
	    	   }
	    	   i--;
	    	   j++;
	        }
	       System.out.println(sb.toString());
		}

		public static void main(String args[]) {
	        FastReader sc = new FastReader();
	        long start = System.currentTimeMillis();

	        String str = sc.next();

	        solve(str, str.length());

	        	long end = System.currentTimeMillis();
	        	NumberFormat formatter = new DecimalFormat("#0.00000");
	        	//System.out.print("Execution time is " + formatter.format((end - start) / 1000d) + " seconds");
	        }
	}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.next();
StringBuilder output = new StringBuilder();
int left = 0, right = input.length();
for (int i = 0; i < input.length() ; i++) {
	if (i % 2 == 0) {
		right--;
		output.append(input.charAt(right));
	} else {
		output.append(input.charAt(left));
		left++;
	}
}
System.out.println(output.reverse().toString());
	}
}

//package codeforce528a;
import java.util.Scanner;
public class NewClass {

    public static void main(String[] args) {
        int n,b,j=0,i,result,sum,maxval=0;

        Scanner scanner = new Scanner(System.in);
        String username = scanner.nextLine();
        double len =username.length();
        int intlen=(int) len;
        char[] a = username.toCharArray();
        n=(int) (Math.ceil(len/2)-1);
        if(len==1||len==2)
            System.out.print(username);
        else
        {
        char[] b_arr=new char[99999];
          b_arr[j++]=a[n];
            for(i=1;i<len/2;i++)
            {
            b_arr[j++]=a[n+i];
            b_arr[j++]=a[n-i];
            }
            if(intlen%2==0)
            {

            for(i=0;i<intlen-1;i++)
            System.out.print(b_arr[i]);
            System.out.println(a[intlen-1]);
            }
            else
            System.out.println(b_arr);
        }
        }
    }
//}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner();
        String cad = sc.next();
        String rta = "";
        for (int i = 0; i < cad.length()/2+cad.length()%2; i++) {
            if(i<cad.length()-i-1){
            rta=String.valueOf(cad.charAt(i))+String.valueOf(cad.charAt(cad.length()-i-1))+rta;
            }else{
                rta=cad.charAt(i)+rta;
                break;
            }
        }
        System.out.println(rta);

    }

    static class Scanner {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");
        int spaces = 0;

        public String nextLine() throws IOException {
            if (spaces-- > 0) {
                return "";
            } else if (st.hasMoreTokens()) {
                return new StringBuilder(st.nextToken("\n")).toString();
            }
            return br.readLine();
        }

        public String next() throws IOException {
            spaces = 0;
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public boolean hasNext() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null) {
                    return false;
                }
                if (line.equals("")) {
                    spaces = Math.max(spaces, 0) + 1;
                }
                st = new StringTokenizer(line);
            }
            return true;
        }
    }
}

import  java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class hacker
{

    // YO fUCK PUSSY MAN
    // Believe yourself you gonna get it
    // Oh!love, oh mine ,gonna fuck you
    public static boolean[] sieve(long n)
    {
        boolean[] prime = new boolean[(int)n+1];
        Arrays.fill(prime,true);
        prime[0] = false;
        prime[1] = false;
        long m = (long)Math.sqrt(n);
        for(int i=2;i<=m;i++)
        {
            if(prime[i])
            {
                for(int k=i*i;k<=n;k+=i)
                {
                    prime[k] = false;
                }
            }
        }
        return prime;
    }

    static long GCD(long a,long b)
    {
        if(a==0 || b==0)
        {
            return 0;
        }
        if(a==b)
        {
            return a;
        }
        if(a>b)
        {
            return GCD(a-b,b);
        }
        return GCD(a,b-a);
    }

    static long CountCoPrimes(long n)
    {
        long res = n;
        for(int i=2;i*i<=n;i++)
        {
            if(n%i==0)
            {
                while(n%i==0)
                {
                    n/=i;
                }
                res-=res/i;
            }
        }
        if(n>1)
        {
            res-=res/n;
        }
        return res;
    }

    //fastest way to find x**n
    static long modularExponentiation(long x,long n,long m)
    {
        long res = 1;
        while(n>0)
        {
            if(n%2==1)
            {
                res = (res*x)%m;
            }
            x =(x*x)%m;
            n/=2;
        }
        return res;
    }

    static long lcm(long a,long b)
    {
        return (a*b)/GCD(a,b);
    }

    static long pow(long a,long b)
    {
        long res = 1;
        while(b>0)
        {
            if((b&1)==1)
            {
                res *= a;
            }

            b >>= 1;
            a *=a;
        }
        return res;
    }

   static long modInverse(long A,long M)
   {
    return modularExponentiation(A,M-2,M);
   }

    static boolean prime(int n)
    {
        for(int i=2;i*i<=n;i++)
        {
            if(i%2==0 ||i%3==0)
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException
    {
      // = new PrintWriter("explicit.out");
        new hacker().run();

    }

    static int rev(int n)
    {
        int x=0;
        int num = 0;
        while(n>0)
        {
            x = n%10;
            num = num*10+x;
            n/=10;

        }
        return num;
    }

    // static int[][] board;
     static Scanner in = new Scanner(System.in);
    static void run() throws IOException
    {
        char[] c = si().toCharArray();
        if(c.length==1)
        {
            System.out.println(c[0]);
        }
        else if(c.length==2)
        {
            System.out.print(c[1]);
            System.out.print(c[0]);
        }
        else if(c.length==3)
        {
            System.out.print(c[1]+""+c[2]+""+c[0]);
        }
        else
        {
            int c1=c.length/2-1;
            int c2 = c.length/2;
            while(c1>=0 || c2<=c.length-1)
            {
                if(c1>=0)
                {
                    System.out.print(c[c1]);
                    c1--;
                }
                else if(c2<=c.length-1);
                {
                    System.out.print(c[c2]);
                    c2++;
                }
                // c1--;
                // c2++;

            }
        }

    }

    static void printL(long a)
    {
        System.out.println(a);
    }
    static void printS(String s)
    {
        System.out.println(s);
    }

    static void swap(char c,char p)
    {
        char t = c;
        c = p;
        p = t;
    }

    static long max(long n,long m)
    {
        return Math.max(n,m);
    }
    static long min(long n,long m)
    {
        return Math.min(n,m);
    }

    static double nd() throws IOException
    {
        return Double.parseDouble(in.next());
    }
    static int ni() throws IOException
    {
        return Integer.parseInt(in.next());
    }

    static long nl() throws IOException
    {
        return Long.parseLong(in.next());
    }

    static String si() throws IOException
    {
        return in.next();
    }

    static int abs(int n)
    {
        return Math.abs(n);
    }

    static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
            {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public int nextInt() throws IOException {return Integer.parseInt(next());}

        public long nextLong() throws IOException {return Long.parseLong(next());}

        public String nextLine() throws IOException {return br.readLine();}

        public boolean ready() throws IOException {return br.ready();}

    }

}

class Pair implements Comparable<Pair>
{
    int value;
    int index;
    public Pair(int v,int i)
    {
        value = v;
        index = i;
    }

    public int compareTo(Pair a)
    {
        return this.value-a.value;
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner();
        String cad = sc.nextLine();
        String rta = "";
        if (cad.length() == 3) {
            rta += cad.charAt(1);
            rta += cad.charAt(2);
            rta += cad.charAt(0);
        } else {
            for (int i = 0; i < cad.length() / 2 + cad.length() % 2; i++) {
                if (i < cad.length() - i - 1) {
                    rta = String.valueOf(cad.charAt(i)) + String.valueOf(cad.charAt(cad.length() - i - 1)) + rta;
                } else {
                    rta = cad.charAt(i) + rta;
                    break;
                }
            }
        }
        System.out.println(rta);

    }

    static class Scanner {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");
        int spaces = 0;

        public String nextLine() throws IOException {
            if (spaces-- > 0) {
                return "";
            } else if (st.hasMoreTokens()) {
                return new StringBuilder(st.nextToken("\n")).toString();
            }
            return br.readLine();
        }

        public String next() throws IOException {
            spaces = 0;
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public boolean hasNext() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null) {
                    return false;
                }
                if (line.equals("")) {
                    spaces = Math.max(spaces, 0) + 1;
                }
                st = new StringTokenizer(line);
            }
            return true;
        }
    }
}

import java.util.Collections;
import java.util.Scanner;
import java.util.Vector;

public class Main {

	public static void main(String[] args) {

		Scanner in=new Scanner(System.in);

		String dec=null;

		dec=in.next();

		int oddvalue=(dec.length()-1)/2;

		int evenvalue=oddvalue+1;

		// 4   1    5

		Vector<String> oddvalues=new Vector();
	String enc=dec.substring(oddvalue,oddvalue+1);
	for(int i=0;i<oddvalue;i++)
	{

		oddvalues.add(dec.substring(i,i+1));

	}
	Vector<String> evenvalues=new Vector<>();
	for(int i=oddvalue+1;i<dec.length();i++)
	{

		evenvalues.add(dec.substring(i,i+1));

	}

Collections.reverse(oddvalues);

	int c1=0,c2=0;
	for(int i=0;i<dec.length()-1;i++)
	{

		if(true)
		{
			if(i%2==0&&c1<evenvalues.size())
			{

				enc+=evenvalues.get(c1++).toString();

			}
			else if(i%2==1&&c2<oddvalues.size())
			{
				enc+=oddvalues.get(c2++).toString();
			}
			System.out.println(enc);
		}
	}
	System.out.println(enc);

	}

}

import java.io.*;    //PrintWriter
import java.math.*;  //BigInteger, BigDecimal
import java.util.*;  //StringTokenizer, ArrayList

public class R528_Div2_A
{
	FastReader in;
	PrintWriter out;

	public static void main(String[] args)  {
		new R528_Div2_A().run();
	}

	void run()
	{
		in = new FastReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	void solve()
	{
		String s = in.next();
		String s2 = "";
		int n = s.length();

		int st = 0, en = n-1;
		for (int i = 0; i < n / 2; i++) {
			s2 = "" + s.charAt(st) + s.charAt(en) + s2;
			st++; en--;
		}
		if (n % 2 == 1) {
			s2 = s2 + s.charAt(n/2);
		}
		out.println(s2);
	}

	//-----------------------------------------------------
	void runWithFiles() {
		in = new FastReader(new File("input.txt"));
		try {
			out = new PrintWriter(new File("output.txt"));
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		solve();
		out.close();
	}

	class FastReader
	{
	    BufferedReader br;
	    StringTokenizer tokenizer;

	    public FastReader(InputStream stream)
	    {
	        br = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }
		public FastReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
				tokenizer = null;
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

	    private String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens())
	            try {
	            	tokenizer = new StringTokenizer(br.readLine());
	            }
	            catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        return tokenizer.nextToken();
	    }
		public String nextLine() {
			try	{
				return br.readLine();
			}
			catch(Exception e) {
				throw(new RuntimeException());
			}
		}

	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	    BigDecimal nextBigDecimal() {
	        return new BigDecimal(next());
	    }
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner cin = new Scanner(System.in);

		String str = cin.next();
		String nrstr = "";
		int len = str.length();

		for(int i = 0; i < len; i++) {

			StringBuilder sb = new StringBuilder(str);

			str = sb.reverse().toString();

			nrstr += str.charAt(0);

			str = str.substring(1);

		}

		for(int i = 0; i < len; i++) {

			System.out.print(nrstr.charAt(len-1-i));

		}

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in Actual solution is at the top
 *
 * @author @Ziklon
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    ARightLeftCipher solver = new ARightLeftCipher();
    solver.solve(1, in, out);
    out.close();
  }

  static class ARightLeftCipher {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      String s = in.readString();
      StringBuilder sb = new StringBuilder();

      int low = 0, hih = s.length() - 1;

      while (hih > low) {
        sb.append(s.charAt(hih--));
        sb.append(s.charAt(low++));
      }
      if (hih == low) sb.append(s.charAt(hih));
      out.printLine(sb.reverse());
    }
  }

  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
      for (int i = 0; i < objects.length; i++) {
        if (i != 0) {
          writer.print(' ');
        }
        writer.print(objects[i]);
      }
    }

    public void printLine(Object... objects) {
      print(objects);
      writer.println();
    }

    public void close() {
      writer.close();
    }
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private InputReader.SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public 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++];
    }

    public String readString() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      StringBuilder res = new StringBuilder();
      do {
        if (Character.isValidCodePoint(c)) {
          res.appendCodePoint(c);
        }
        c = read();
      } while (!isSpaceChar(c));
      return res.toString();
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);
    }
  }
}

import java.io.*;
import java.util.StringTokenizer;

public class A {

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        String cipher = reader.readWord();
        char[] text = new char[cipher.length()];

        int leftStart = 0;
        int rightStart = cipher.length() - 1;
        int i = cipher.length() - 1;
        if(cipher.length()%2 == 1) {
            text[cipher.length()-1] = cipher.charAt(0);
            leftStart = 1;
            rightStart = cipher.length() -1;
        }
        boolean fromLeft = false;
        for(; i >= 0; i--) {
            if(fromLeft) {
                text[i] = cipher.charAt(leftStart++);
                fromLeft = false;
            } else {
                text[i] = cipher.charAt(rightStart--);
                fromLeft = true;
            }

        }

        writer.println(text);
        writer.close();
    }

    public static class InputReader {
        StringTokenizer st;
        BufferedReader br;

        public InputReader(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public String readWord() {
            if(st == null || !st.hasMoreTokens()) {
                try {
                    String s = br.readLine();
                    st = new StringTokenizer(s);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            return st.nextToken();
        }

        public long readLong() {
            return Long.parseLong(readWord());
        }

        public int readInt() {
            return Integer.parseInt(readWord());
        }
    }

}

//package codeforcesa;
import java.util.*;
public class RightLeftCipher {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String t=in.nextLine();
        String s="";
        int index=0;

        if(t.length()%2==0)
        {
            index=t.length()/2 -1;
        }
        else
        {
            index=t.length()/2;
        }
        s=s+t.charAt(index);
        int count=1;
        int flag=0;
        for(int i=index;i<t.length()-1;)
        {
            if(flag==0)
            {
                flag=1;
                i=index+count;
                s=s+t.charAt(i);
            }
            else
            {
                flag=0;
                i=index-count;
                s=s+t.charAt(i);
                count++;
            }
        }
        System.out.println(s);
    }
}

import java.util.Scanner;
public class ciphers
{
    public static void main(String args[])
    {
        Scanner x= new Scanner(System.in);
        String s= x.nextLine();
        int n=s.length();
        int i, k=0;
        char c[]= new char[n];
        if(n==1)
        System.out.println(s);
        else
        {
        for(i=0; i<n/2; i++)
        {
            c[n-2-k]=s.charAt(i);
            c[n-1-k]=s.charAt(n-1-i);
            k=k+2;
        }
        if(n%2!=0)
        c[0]= s.charAt(n/2);
        for(i=0; i<n; i++)
        System.out.print(c[i]);
    }
    }
}

import java.util.Scanner;

public class RightLeftCipher {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        StringBuilder sb = new StringBuilder();
        if(s.length()==1){
            System.out.println(s);
        }
        int index = (int)Math.ceil(s.length() / (double)2) -1;
        sb.append(s.charAt(index));
        for (int i = 1; i < s.length(); i++) {
            if(i%2==0){
                index = index - i;
            }else {
                index = index + i;
            }
            sb.append(s.charAt(index));
        }
        System.out.println(sb);
    }
}

import java.util.Scanner;

public class JavaApplication141 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String x = "erfdcoeocs";
        char c [] = new char[x.length()];
        int s = 0;

        if(x.length() % 2 == 0){
            for(int i= x.length()/2-1; i>=0; i--){
                c[s++] +=  x.charAt(i);
                c[s++] += x.charAt(x.length() - 1 - i);
            }
        }else{
            c[s++] = x.charAt(x.length()/2);
            for(int i=x.length()/2-1; i>=0; i--){
                c[s++] = x.charAt(x.length()-1-i);
                c[s++] = x.charAt(i);
            }
        }

        for(int i=0; i<x.length(); i++){
            System.out.print(c[i]);
        }

    }

}

import java.util.Scanner;

public class Z {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        String in = sc.nextLine();

        StringBuilder res = new StringBuilder();

        int startPos = in.length() / 2 - 1;

        for (int i = 0; i < in.length() - 1; i++) {
            if (i == 0) {
                res.append(in.charAt(startPos));
                continue;
            }
            if (startPos + i < in.length())
            res.append(in.charAt(startPos + i));
            if (startPos - i >= 0)
            res.append(in.charAt(startPos - i));
        }

        System.out.println(res.toString());
    }

}

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

       String pal=sc.next();
       String n="";
       int a=0;
       for(int i=pal.length()-1; i>=pal.length()/2; i--){
           n+=pal.charAt(i);
        if( a<i){
           n+=pal.charAt(a);
           a++;
          }

       }
       String p="";
       for(int e=pal.length()-1; e>=0; e--){
           p+=n.charAt(e);
       }
        System.out.println(p);
    }

}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;

public class george
{
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
 static int max(int a[],int n) {
	 int max=a[0];
	 int ind=0;
	 for(int i=1;i<n;i++) {
		 if(a[i]>=max) {
			 max=a[i];
			 ind=i;
		 }
	 }
	 return ind;
 }
 static int min(int a[],int n) {
	 int min=a[0];
	 int ind=0;
	 for(int i=1;i<n;i++) {
		 if(a[i]<min) {
			 min=a[i];
			 ind=i;
		 }
	 }
	 return ind;
 }
 static boolean fun(int i) {
	 for(int j=3;j<=20;j++) {
		 if(i%j!=0) {
			 return false;
		 }
	 }
	 return true;
 }
 static int bin(int arr[], int l, int r, int x)
 {
     if (r>=l)
     {
         int mid = l + (r - l)/2;

         if (arr[mid] == x)
            return mid;

         if (arr[mid] > x)
            return bin(arr, l, mid-1, x);
         return bin(arr, mid+1, r, x);
     }

     return -1;
 }
 static boolean isPalindrome(int n)
 {

     int divisor = 1;
     while (n / divisor >= 10)
         divisor *= 10;

     while (n != 0)
     {
         int leading = n / divisor;
         int trailing = n % 10;

         if (leading != trailing)
             return false;

         n = (n % divisor) / 10;

         divisor = divisor / 100;
     }
     return true;
 }
 public static String sortString(String inputString)
 {
     // convert input string to char array
     char tempArray[] = inputString.toCharArray();

     // sort tempArray
     Arrays.sort(tempArray);

     // return new sorted string
     return new String(tempArray);
 }
 public static boolean allDifferent( int[]a){
	    for(int i = 0; i < a.length; i++){
	        if(a[i] != 0){
	            return true;
	        }

	    }
	    return false;
}

    public static void main(String[] args) throws IOException
    {
        Reader s=new Reader();
        String st = s.readLine();
        char [] da = st.toCharArray();
//        if(st.length()<=2) {
//        	System.out.println(st);
//        	System.exit(0);
//        }
        int len = st.length()-2;
        int j=1;
        int ss=1;
        int r,l;
        r=l=(st.length()/2)-1;
        char ans[]=new char[st.length()];
        ans[0]=st.charAt((st.length()/2)-1);

        while(len>0) {
        	if(j%2==0) {
        		l--;
        		ans[ss]=da[l];
        	} else {

        		r++;

        		ans[ss]=da[r];
        	}
        	ss++;
        	j++;
        	len--;

        }
        System.out.println(String.copyValueOf(ans));
    }
}

//http://codeforces.com/problemset/problem/1085/A
import java.util.Scanner;
public class _1085A {
    public static void main(String[] args) {
        Scanner scnr = new Scanner(System.in);
        String encrypted = scnr.next();
        String decrypted = encrypted.substring(encrypted.length() - 1);
        for(int i = 1; i < encrypted.length(); i++)
        {
            if(i%2 == 1)
            {
                decrypted = encrypted.charAt(i/2) + decrypted;
            }
            else if(i%2 == 0)
            {
                decrypted = encrypted.charAt(encrypted.length() - 1 - i/2) + decrypted;
            }
        }
        System.out.println(decrypted);
    }
}

import java.io.*;
import java.util.*;

public class Pascal {

    static PrintWriter out = new PrintWriter(System.out);
    static BufferedReader br;
    static StringTokenizer st;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String s = next();
        if (s.length() % 2 == 0){
            out.print(s.charAt(s.length() / 2 - 1));
            for (int i = 1; i < s.length() / 2; i++) {
                out.print(s.charAt(s.length() / 2 - 1 + i));
                out.print(s.charAt(s.length() / 2 - 1 - i));
            }
            if(s.length() > 1) out.print(s.charAt(s.length() - 1));
        }
        else {
            out.print(s.charAt(s.length() / 2));
            for (int i = 1; i < s.length() / 2; i++) {
                out.print(s.charAt(s.length() / 2 + i));
                out.print(s.charAt(s.length() / 2 - i));
            }
            if(s.length() > 1) out.print(s.charAt(0));
        }
        out.close();
    }

    static int nextInt() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }

    static long nextLong() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return Long.parseLong(st.nextToken());
    }

    static String next() throws IOException {
        if (st == null || !st.hasMoreElements()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String t = in.nextLine();
        int len = t.length();
        char[] res = new char[len+2];
        char[] x = t.toCharArray();
        double k = 1;
        if(len % 2 == 0){
            res[0] = x[(len/2)-1];
            for(int i = 1; i < len; i++) {
                res[i] = x[((int)((len / 2) + ((Math.pow(-1, (double)(i-1))  * (int)(k))))-1)];
                k+=0.5;
            }
        }
        else{
            res[0] = x[len/2];
            for(int i = 1; i < len; i++) {
                res[i] = x[((int)((len / 2) + ((Math.pow(-1, (double)(i-1))  * (int)(k)))))];
                k+=0.5;
            }
        }
        String myStr = new String(res);
        System.out.println(myStr);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner();
        String cad = sc.nextLine();
        String rta = "";
        for (int i = 0; i < cad.length() / 2 + cad.length() % 2; i++) {
            if (i < cad.length() - i - 1) {
                rta = String.valueOf(cad.charAt(i)) + String.valueOf(cad.charAt(cad.length() - i - 1)) + rta;
            } else {
                rta = cad.charAt(i) + rta;
                break;
            }
            if (i == 50) {
                break;
            }
        }
        System.out.println(rta);

    }

    static class Scanner {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");
        int spaces = 0;

        public String nextLine() throws IOException {
            if (spaces-- > 0) {
                return "";
            } else if (st.hasMoreTokens()) {
                return new StringBuilder(st.nextToken("\n")).toString();
            }
            return br.readLine();
        }

        public String next() throws IOException {
            spaces = 0;
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public boolean hasNext() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null) {
                    return false;
                }
                if (line.equals("")) {
                    spaces = Math.max(spaces, 0) + 1;
                }
                st = new StringTokenizer(line);
            }
            return true;
        }
    }
}

import java.util.*;
import java.io.*;

public class gfg
{
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

	public static void main(String[] args)
	{
		FastReader sc = new FastReader();
		String s = sc.next();
		if(s.length()==3)
		{
			System.out.println(s.substring(1,3) + s.charAt(0));
			return;
		}
		String ans = "";
		while(!s.isBlank())
		{
			int ch = 0;
			if(s.length()%2==0)
				ch = s.length()/2-1;
			else
				ch = s.length()/2;
			ans += s.charAt(ch);
			s = s.substring(0, ch) + s.substring(ch+1);
		}
		System.out.println(ans);
	}
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in =new Scanner(System.in);
		String s=in.next();
		int n=s.length();
		if (n%2==1)
	{String u="";
	for(int i=0;i<(((n-1)/2)+1);i++)
	{
		if (i==((n-1)/2))

		{	u=""+(char)s.charAt(n-1-i)+""+(char)s.charAt(i)+""+u;}
		else
			{u=""+(char)s.charAt(i)+""+u;}
	System.out.println(u);
	}   }
else
{
	String u="";
	for (int i=0;i<n/2;i++)
	{
		u=""+(char)s.charAt(i)+""+(char)s.charAt(n-1-i)+""+u;}
	System.out.print(u);

	}
}
}

import java.io.*;

public class Main {
    static BufferedReader jin = new BufferedReader( new InputStreamReader( System.in ) );
    static char[] t = new char[50];
    static int n, m;

    public static void main(String[] args) throws Exception {

        for( n = 0 ; jin.ready() ; ) t[ n++ ] = (char)jin.read();

        /** t = "qwert".toCharArray(); /**/
        /** n = t.length; /**/
        /** System.out.println( " - " + n + " - " + Arrays.toString(t) ); /**/

        m = n / 2 + n % 2 ;

        /** System.out.println( " - " + m + " - " ); /**/

        for( int i = 1 ; i <= n ; i++ ) {
            System.out.print( t[m-1] );
            m = m + i * ( i % 2 == 1 ? 1 : -1 );
        }
    }

    static int nextInt() throws  Exception {
        int res = 0;
        boolean neg;
        int ch = jin.read();
        while( ch <= ' ' ) ch = jin.read();
        if( neg = ch == '-' ) ch = jin.read();
        do{ res = res * 10 + ch - '0';
        } while( jin.ready() ? ( '0' <= ( ch = jin.read() ) && ch <= '9' ) : false );
        return neg ? -res : res ;
    }
}

//package prac;
import java.util.*;
//import java.math.*;
public class Main {
	static Scanner scn = new Scanner(System.in);
	public static void main(String[] args) {
		String t = scn.nextLine();
		System.out.println(stringinverse(t));

	}
	private static String stringinverse(String t) {
		if(t.length()==1){
			return t;
		}
		int mid = t.length()/2-1;
		String ans = "";
		ans +=t.charAt(mid);
//		System.out.println(ans);
		for(int i = 1;mid-i>=0&&mid+i<t.length();i++){
			ans+=t.charAt(mid+i);
			ans+=t.charAt(mid-i);
		}
		if(ans.length()==t.length()-1){
			ans+=t.charAt(t.length()-1);
		}
		return ans;
	}
	private static int teamform(int[] arr) {
		Arrays.sort(arr);
		int ans = 0;
		for(int i = 0;i<arr.length;i+=2){
			ans+=Math.abs(arr[i]-arr[i+1]);
		}
		return ans;
	}

}

//jsonW0
//Java 8
import java.util.*;

public class RL_Cipher
{
   public static void main(String[] args)
   {
      Scanner input = new Scanner(System.in);
      String k = input.next();
      String orig = "";
      for(int a=0; k.length()!=0; a++) {
         orig = add(orig,k.substring(k.length()-1,k.length()));
         k = k.substring(0,k.length()-1);
         a++;
         if(k.length()!=0) {
            orig = add(orig, k.substring(0,1));
            k = k.substring(1);
         }
      }
      System.out.println(orig);
   }
   public static String add(String o, String k)
   {
      o = k + o;
      return o;
   }
}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        char[] chars = scanner.next().toCharArray();
        int a = 0;

        int c = chars.length;
        StringBuilder s = new StringBuilder();
        while(c>0){
            s.append(chars[chars.length - 1 - a]);
            s.append(chars[a]);
            a++;
            c-=2;
        }
        StringBuilder s2 = new StringBuilder();

        for (int i = s.length()-1; i >= 0; i--) {
            s2.append(s.charAt(i));
        }

        System.out.println(s2.toString());

    }
}

import java.util.*;

public class stringss {
public static void main(String args[]) {
Scanner sc= new Scanner(System.in);
String s=sc.next();
String a="ncteho";
int k=s.length();
if(k==1)
{System.out.println(s);
System. exit(0);
}
k=k/2;
k=k-1;
String temp="";
char[] result=s.toCharArray();
temp=temp+result[k];
int i,j;
for(i=k+1,j=k-1; i<=s.length() && j>=0;i++,j--)
{temp=temp+result[i];
temp=temp+result[j];
}
if(s.length()%2==0)
{
temp=temp+result[s.length()-1];
}
System.out.println(temp);
}

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner cin = new Scanner(System.in);

		String str = cin.next();
		String nrstr = "";
		int len = str.length();

		for(int i = 0; i < len; i++) {

			StringBuilder sb = new StringBuilder(str);

			str = sb.reverse().toString();

			nrstr += str.charAt(0);

			str = str.substring(1);

		}

		for(int i = 0; i < len; i++) {

			System.out.print(nrstr.charAt(len-1-i));

		}

	}

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner cin = new Scanner(System.in);

		String str = cin.next();

		String nrstr = "";

		int l = 0;
		int r = 0;
		boolean b = false;

		if (str.length() % 2 == 0 || str.length() <= 3) {

			for (int i = 0; i < str.length(); i++) {

				if (b == false) {

					nrstr += str.charAt(str.length() - 1 - r);
					r++;
					b = true;

				} else {

					nrstr += str.charAt(l);
					l++;
					b = false;

				}

			}

			String result = "";

			for (int i = 0; i < str.length(); i++) {

				result += nrstr.charAt(str.length() - 1 - i);

			}

			System.out.println(result);

		} else {

			for (int i = 0; i < str.length(); i++) {

				if (b == true) {

					nrstr += str.charAt(str.length() - 1 - r);
					r++;
					b = false;

				} else {

					nrstr += str.charAt(l);
					l++;
					b = true;

				}

			}

			String result = "";

			for (int i = 0; i < str.length(); i++) {

				result += nrstr.charAt(str.length() - 1 - i);

			}

			System.out.println(result);

		}

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class Main {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner();
        String cad = sc.next();
        String rta = "";
        for (int i = 1; i < cad.length(); i++) {
            if (i % 2 == 0) {
                rta = cad.charAt(i)+rta;
            } else {
                rta += cad.charAt(i);
            }
        }
        System.out.println(rta);

    }

    static class Scanner {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");
        int spaces = 0;

        public String nextLine() throws IOException {
            if (spaces-- > 0) {
                return "";
            } else if (st.hasMoreTokens()) {
                return new StringBuilder(st.nextToken("\n")).toString();
            }
            return br.readLine();
        }

        public String next() throws IOException {
            spaces = 0;
            while (!st.hasMoreTokens()) {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public boolean hasNext() throws IOException {
            while (!st.hasMoreTokens()) {
                String line = br.readLine();
                if (line == null) {
                    return false;
                }
                if (line.equals("")) {
                    spaces = Math.max(spaces, 0) + 1;
                }
                st = new StringTokenizer(line);
            }
            return true;
        }
    }
}

import  java.io.IOException;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class hacker
{

    // YO fUCK PUSSY MAN
    // Believe yourself you gonna get it
    // Oh!love, oh mine ,gonna fuck you
    public static boolean[] sieve(long n)
    {
        boolean[] prime = new boolean[(int)n+1];
        Arrays.fill(prime,true);
        prime[0] = false;
        prime[1] = false;
        long m = (long)Math.sqrt(n);
        for(int i=2;i<=m;i++)
        {
            if(prime[i])
            {
                for(int k=i*i;k<=n;k+=i)
                {
                    prime[k] = false;
                }
            }
        }
        return prime;
    }

    static long GCD(long a,long b)
    {
        if(a==0 || b==0)
        {
            return 0;
        }
        if(a==b)
        {
            return a;
        }
        if(a>b)
        {
            return GCD(a-b,b);
        }
        return GCD(a,b-a);
    }

    static long CountCoPrimes(long n)
    {
        long res = n;
        for(int i=2;i*i<=n;i++)
        {
            if(n%i==0)
            {
                while(n%i==0)
                {
                    n/=i;
                }
                res-=res/i;
            }
        }
        if(n>1)
        {
            res-=res/n;
        }
        return res;
    }

    //fastest way to find x**n
    static long modularExponentiation(long x,long n,long m)
    {
        long res = 1;
        while(n>0)
        {
            if(n%2==1)
            {
                res = (res*x)%m;
            }
            x =(x*x)%m;
            n/=2;
        }
        return res;
    }

    static long lcm(long a,long b)
    {
        return (a*b)/GCD(a,b);
    }

    static long pow(long a,long b)
    {
        long res = 1;
        while(b>0)
        {
            if((b&1)==1)
            {
                res *= a;
            }

            b >>= 1;
            a *=a;
        }
        return res;
    }

   static long modInverse(long A,long M)
   {
    return modularExponentiation(A,M-2,M);
   }

    static boolean prime(int n)
    {
        for(int i=2;i*i<=n;i++)
        {
            if(i%2==0 ||i%3==0)
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException
    {
      // = new PrintWriter("explicit.out");
        new hacker().run();

    }

    static int rev(int n)
    {
        int x=0;
        int num = 0;
        while(n>0)
        {
            x = n%10;
            num = num*10+x;
            n/=10;

        }
        return num;
    }

    // static int[][] board;
     static Scanner in = new Scanner(System.in);
    static void run() throws IOException
    {
        char[] c = si().toCharArray();
        if(c.length==1)
        {
            System.out.println(c[0]);
        }
        else if(c.length==2)
        {
            System.out.print(c[0]);
            System.out.print(c[1]);
        }
        else if(c.length==3)
        {
            System.out.print(c[1]+""+c[2]+""+c[0]);
        }
        else
        {
            int c1=c.length/2-1;
            int c2 = c.length/2;
            while(c1>=0 || c2<=c.length-1)
            {
                if(c1>=0)
                {
                    System.out.print(c[c1]);
                    c1--;
                }
                else if(c2<=c.length-1);
                {
                    System.out.print(c[c2]);
                    c2++;
                }
                // c1--;
                // c2++;

            }
        }

    }

    static void printL(long a)
    {
        System.out.println(a);
    }
    static void printS(String s)
    {
        System.out.println(s);
    }

    static void swap(char c,char p)
    {
        char t = c;
        c = p;
        p = t;
    }

    static long max(long n,long m)
    {
        return Math.max(n,m);
    }
    static long min(long n,long m)
    {
        return Math.min(n,m);
    }

    static double nd() throws IOException
    {
        return Double.parseDouble(in.next());
    }
    static int ni() throws IOException
    {
        return Integer.parseInt(in.next());
    }

    static long nl() throws IOException
    {
        return Long.parseLong(in.next());
    }

    static String si() throws IOException
    {
        return in.next();
    }

    static int abs(int n)
    {
        return Math.abs(n);
    }

    static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){  br = new BufferedReader(new InputStreamReader(s));}

        public String next() throws IOException
        {
            while (st == null || !st.hasMoreTokens())
            {
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }

        public int nextInt() throws IOException {return Integer.parseInt(next());}

        public long nextLong() throws IOException {return Long.parseLong(next());}

        public String nextLine() throws IOException {return br.readLine();}

        public boolean ready() throws IOException {return br.ready();}

    }

}

class Pair implements Comparable<Pair>
{
    int value;
    int index;
    public Pair(int v,int i)
    {
        value = v;
        index = i;
    }

    public int compareTo(Pair a)
    {
        return this.value-a.value;
    }

}

import java.io.*;    //PrintWriter
import java.math.*;  //BigInteger, BigDecimal
import java.util.*;  //StringTokenizer, ArrayList

public class R528_Div2_A
{
	FastReader in;
	PrintWriter out;

	public static void main(String[] args)  {
		new R528_Div2_A().run();
	}

	void run()
	{
		in = new FastReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	void solve()
	{
		String s = in.next();
		String s2 = "";
		int n = s.length();

		int st = 0, en = n-1;
		for (int i = 0; i < n / 2; i++) {
			s2 = "" + s.charAt(st) + s.charAt(en) + s2;
			st++; en--;
		}
		if (n % 2 == 1) {
			s2 = s.charAt(n/2) + s2;
		}
		out.println(s2);
	}

	//-----------------------------------------------------
	void runWithFiles() {
		in = new FastReader(new File("input.txt"));
		try {
			out = new PrintWriter(new File("output.txt"));
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		solve();
		out.close();
	}

	class FastReader
	{
	    BufferedReader br;
	    StringTokenizer tokenizer;

	    public FastReader(InputStream stream)
	    {
	        br = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }
		public FastReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
				tokenizer = null;
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

	    private String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens())
	            try {
	            	tokenizer = new StringTokenizer(br.readLine());
	            }
	            catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        return tokenizer.nextToken();
	    }
		public String nextLine() {
			try	{
				return br.readLine();
			}
			catch(Exception e) {
				throw(new RuntimeException());
			}
		}

	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	    BigDecimal nextBigDecimal() {
	        return new BigDecimal(next());
	    }
	}
}

import java.util.*;
public class RightLeftCipher {

	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String res = "";
		int i,j;

		if(s.length()%2 == 0)
		{
			res = s.charAt((s.length()/2)-1) + "";
			i = (s.length()/2)-2;
			j = (s.length()/2);
		}

		else
		{
			res = s.charAt(s.length()/2) + "";
			i = (s.length()/2)-1;
			j = (s.length()/2)+1;
		}

		if(s.length() == 2)
			System.out.println(s.charAt(1) + "" + s.charAt(0));
		else
		{
			while(i >= 0 && j < s.length())
			{
				res = res + s.charAt(j);
				j++;
				res = res + s.charAt(i);
				i--;

				if(i < 0 && j < s.length())
				{
					while(j < s.length())
					{
						res = res + s.charAt(j);
						j++;
					}

					break;
				}

				else
				{
					if(i >= 0 && j > s.length())
					{
						while(i >= 0)
						{
							res = res + s.charAt(i);
							i--;
						}

						break;
					}
				}
			}

			System.out.println(res);
		}

		sc.close();
	}
}

//package codeforce528a;
import java.util.Scanner;
public class NewClass {

    public static void main(String[] args) {
        int n,b,j=0,i,result,sum,maxval=0;

        Scanner scanner = new Scanner(System.in);
        String username = scanner.nextLine();
        double len =username.length();
        int intlen=(int) len;
        char[] a = username.toCharArray();
        n=(int) (Math.ceil(len/2)-1);
        if(len==1||len==2)
            System.out.print(username);
        else
        {
        char[] b_arr=new char[999];
          b_arr[j++]=a[n];
            for(i=1;i<len/2;i++)
            {
            b_arr[j++]=a[n+i];
            b_arr[j++]=a[n-i];
            }
            if(intlen%2==0)
            {

            for(i=0;i<intlen-1;i++)
            System.out.print(b_arr[i]);
            System.out.println(a[intlen-1]);
            }
            else
            System.out.println(b_arr);
        }
        }
    }
//}

import java.util.Scanner;

public class TaskA {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String encrypted = scanner.nextLine();
        char[] decrypted = new char[encrypted.length()];
        int first = encrypted.length() / 2 - 1;
        if (encrypted.length() <= 2) {
            System.out.println(encrypted);
            return;
        } else if (encrypted.length() == 3) {
            System.out.print(encrypted.charAt(1));
            System.out.print(encrypted.charAt(2));
            System.out.print(encrypted.charAt(0));
            return;
        }

        decrypted[0] = encrypted.charAt(first);
        for (int i = 1, k = first + 1; i < encrypted.length() && k < encrypted.length(); i += 2, k++) {
            decrypted[i] = encrypted.charAt(k);
        }
        for (int i = 2, k = first - 1; i < encrypted.length() && k >= 0; i += 2, k-- ) {
            decrypted[i] = encrypted.charAt(k);
        }
        for (int i = 0; i < encrypted.length(); i++) {
            System.out.print(decrypted[i]);
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Washoum
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        inputClass in = new inputClass(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ARightLeftCipher solver = new ARightLeftCipher();
        solver.solve(1, in, out);
        out.close();
    }

    static class ARightLeftCipher {
        public void solve(int testNumber, inputClass sc, PrintWriter out) {
            StringBuilder ch = new StringBuilder();
            StringBuilder s = new StringBuilder().append(sc.nextLine());
            if (s.length() == 2) {
                out.println(s);
                return;
            }
            while (s.length() > 0) {
                ch.insert(0, s.charAt(s.length() - 1));
                s.deleteCharAt(s.length() - 1);
                if (s.length() > 0) {

                    ch.insert(0, s.charAt(0));
                    s.deleteCharAt(0);
                }
            }
            out.println(ch);
        }

    }

    static class inputClass {
        BufferedReader br;

        public inputClass(InputStream in) {

            br = new BufferedReader(new InputStreamReader(in));
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
}

import java.util.LinkedList;
import java.util.Scanner;

public class Solution {

    public static String Cat(String S) {
        return new StringBuffer(S).reverse().toString();
    }

    public static String Cat1(String S) {
        return new StringBuffer(S).reverse().toString();
    }

    public static void main(String args[]) {
        Scanner Input = new Scanner(System.in);
        LinkedList<Character> L = new LinkedList();
        String S = Input.next();
        // boolean T = true;
        for (int I = 0; I < S.length(); I++) {
            L.add(S.charAt(I));
        }
        String Ans = "";
        boolean T = true;
        while (!L.isEmpty()) {
            if (T) {
                Ans += L.pollLast() + "";
                T = false;
            } else {
                Ans += L.pollFirst() + "";
                T = true;
            }
        }
        System.out.println(Cat(Ans));

    }

    public static String Cat2(String S) {
        return new StringBuffer(S).reverse().toString();
    }

    public static String Cat3(String S) {
        return new StringBuffer(S).reverse().toString();
    }

}

import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.*;
import java.io.*;
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String t = br.readLine();
        char[] ans = new char[t.length()+10];
        if(t.length()%2==0){
            int l = t.length()/2-1;
            int r = t.length()/2;
            int cnt = 0 ;
            while(l>=0 && r < t.length()) {
                ans[cnt++] = t.charAt(l);
                ans[cnt++] = t.charAt(r);
                l--;
                r++;
            }
            for(int i=0;i<t.length();i++){
                System.out.print(ans[i]);
            }
        }
        else{
            int l = t.length()/2;
            int r = t.length()/2;
            int cnt = 0 ;
            while(l>=0 && r < t.length()) {
                ans[cnt++] = t.charAt(l);
                if(cnt!=1)
                ans[cnt++] = t.charAt(r);
                l--;
                r++;
            }
            for(int i=0;i<t.length();i++){
                System.out.print(ans[i]);
            }
        }
    }
}

/*# Date 23 Dec 2018;
# http://codeforces.com/contest/1087/problem/A  Right-Left Cipher
*/

import java.util.Scanner;

public class probA1087 {
    public static void main(String[] args)
    {
        //System.out.println("Please enter String");
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        char[] a=s1.toCharArray();
        int length = a.length;
        String result ="";

        for(int x=0;x<length;x++){
            //System.out.println(a[x]);

            if (x % 2 == 0)
                result = a[x] + result;
            else
                result = result + a[x];
        }

        //System.out.println(c);
        System.out.println(result);
        //System.out.println(length);
    }
}

import java.util.*;
import java.lang.*;

public class cipher{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String str = scan.nextLine();

		int i=0;
		int j=str.length()-1;
		StringBuilder sb = new StringBuilder();
		if(sb.length()%2==0){
			sb.append(str.charAt(j));
			j--;
		}
		while(i<=j){
			sb.append(str.charAt(i));
			i++;
			if(i>j){
				break;
			}
			sb.append(str.charAt(j));
			j--;
	    }

	    System.out.println(sb.reverse().toString());
	}

}

//package dp;

import java.util.Scanner;

public class A1085 {
	public static void main(String[] args)
	{
		Scanner s=new Scanner(System.in);
		String str=s.next();
		if(str.length()<=2)
			System.out.println(str);
		int mid=-1;
		if(str.length()%2==0)
			mid=(str.length()/2)-1;
		else
			mid=str.length()/2;
		StringBuilder sb=new StringBuilder();
		sb.append(str.charAt(mid));
		for(int i=mid-1,j=mid+1;j<str.length();i--,j++)
		{
			sb.append(str.charAt(j));
			if(i>=0)
			sb.append(str.charAt(i));
		}
		System.out.println(sb.toString());
	}
}

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String input = scanner.next();
		ArrayList<Character> result = new ArrayList<>(input.length());
		for (int i = 0; i < input.length(); i++) {
			if (i % 2 == 0) {
				result.add(0, input.charAt(i));
			} else {
				result.add(result.size(), input.charAt(i));
			}
		}
		StringBuilder builder = new StringBuilder();
		for (Character c : result) {
			builder.append(c);
		}
		System.out.println(builder.toString());
	}
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
*/
import java.util.*;
import java.io.*;

   public class A
   {
      public static void main(String args[]) throws Exception
      {
         //BufferedReader infile = new BufferedReader(new FileReader("cowdate.in"));
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         String input = st.nextToken();
         //solve
         String res = "";
         int N = input.length();
         if(true)
         {
            for(int i=0; i < N/2; i++)
            {
               res = input.charAt(N-i-1)+res;
               res = input.charAt(i)+res;
            }
            if(N%2 == 1)
               res = input.charAt(N/2)+res;
         }
         System.out.println(res);
      }
   }

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Vadim
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        A solver = new A();
        solver.solve(1, in, out);
        out.close();
    }

    static class A {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            String s = in.ns();
            int n = s.length();
            int mid = n / 2 - 1;
            if (n % 2 == 1)
                mid++;
            StringBuilder sb = new StringBuilder();
            sb.append(s.charAt(mid));
            System.out.println("mid = " + mid);
            int rem = n - 1;
            int i = 0;
            while (rem > 0) {
                sb.append(s.charAt(mid + i + 1));
                rem--;
                if (rem == 0) break;
                sb.append(s.charAt(mid - i - 1));
                rem--;
                i++;
            }
            out.println(sb.toString());
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

        public String ns() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String rl = in.readLine();
                    if (rl == null) {
                        return null;
                    }
                    st = new StringTokenizer(rl);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

    }
}

import java.util.Scanner;

public class Z {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        String in = sc.nextLine();

        StringBuilder res = new StringBuilder();

        int startPos = in.length() / 2 - 1;

        for (int i = 0; i < in.length() - 1; i++) {
            if (i == 0) {
                res.append(in.charAt(startPos));
                continue;
            }
            if (startPos + i < in.length())
            res.append(in.charAt(startPos + i));
            if (startPos - i >= 0)
            res.append(in.charAt(startPos - i));
        }

        System.out.println(res.toString());
    }

}

import java.util.*;
import java.io.*;

public class gfg
{
	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

	public static void main(String[] args)
	{
		FastReader sc = new FastReader();
		String s = sc.next();
		String ans = "";
		while(!s.isBlank())
		{
			int ch = 0;
			if(s.length()%2==0)
				ch = s.length()/2-1;
			else
				ch = s.length()/2;
			ans += s.charAt(ch);
			s = s.substring(0, ch) + s.substring(ch+1);
		}
		System.out.println(ans);
	}
}

// "static void main" must be defined in a public class.
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String ans ="";
        int x =0;
        while(s.length()>0){
            char z = x==0?s.charAt(s.length()-1):s.charAt(0);
            if(x==0)
                s=s.substring(0,s.length()-1);
            else
                s=s.substring(1);
            ans = z+ans;
            x=~x;
        }
        System.out.println(ans);
    }
}

import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        MyScanner in = new MyScanner(System.in);
        OutputWriter out = new OutputWriter(System.out);
        String s = in.next();
        StringBuilder b = new StringBuilder();
        int p0=0;
        int n = s.length();
        int p1=n-1;
        while (p0<=p1)
        {
            b.append(s.charAt(p1));
            p1--;
            if (p0<=p1)
            {
                b.append(s.charAt(p0));
                p0++;
            }
        }
        String t =b.reverse().toString();
        out.printLine(t);
        out.flush();
    }
}
class MyScanner {

    StringTokenizer st;
    BufferedReader br;

    public MyScanner(InputStream s) {
        br = new BufferedReader(new InputStreamReader(s));
    }

    public MyScanner (FileReader f) {
        br = new BufferedReader(f);
    }

    public String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public String nextLine() throws IOException {
        return br.readLine();
    }

    public double nextDouble() throws IOException {
        String x = next();
        StringBuilder sb = new StringBuilder("0");
        double res = 0, f = 1;
        boolean dec = false, neg = false;
        int start = 0;
        if (x.charAt(0) == '-') {
            neg = true;
            start++;
        }
        for (int i = start; i < x.length(); i++)
            if (x.charAt(i) == '.') {
                res = Long.parseLong(sb.toString());
                sb = new StringBuilder("0");
                dec = true;
            } else {
                sb.append(x.charAt(i));
                if (dec)
                    f *= 10;
            }
        res += Long.parseLong(sb.toString()) / f;
        return res * (neg ? -1 : 1);
    }

    public boolean ready() throws IOException {
        return br.ready();
    }

    public boolean nextEmpty() throws IOException {
        String s = nextLine();
        st = new StringTokenizer(s);
        return s.isEmpty();
    }
}

class pair  implements Comparable
{
    int key;
    int value;
    int index;
    public pair(Object key, Object value,Object index) {

        this.key = (int)key;
        this.value=(int)value;
        this.index = (int)index;
    }
    @Override
    public int compareTo(Object o) {
        pair temp =(pair)o;
        return  value-temp.value;
    }
}
class Graph {

    int n;
    ArrayList<Integer>[] adjList;

    public Graph(int n) {
        this.n = n;
        adjList = new ArrayList[n];
        for (int i = 0; i < n; i++)
            adjList[i] = new ArrayList<>();
    }

}

class InputReader {

    private final InputStream stream;
    private final byte[] buf = new byte[8192];
    private int curChar, snumChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (snumChars == -1)
            throw new InputMismatchException();
        if (curChar >= snumChars) {
            curChar = 0;
            try {
                snumChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (snumChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        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 {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public int[] nextIntArray(int n) {
        int a[] = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        return a;
    }

    public String readString() {
        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 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();
    }

    public boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private boolean isEndOfLine(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

    public void flush() {
        writer.flush();
    }

}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan  = new Scanner(System.in);
        String input = scan.nextLine();
        char[] letters = input.toCharArray();

        char[] result = new char[letters.length];
        System.out.println(letters.length);
        System.out.println(result.length);

        int first = (letters.length%2 == 0)? (letters.length/2 - 1) : letters.length/2;
        int next = first + 1;
        if (letters.length == 1) {
            System.out.println(input);
            return;
        }
        for (int i = 0; i < letters.length; i++) {
            System.out.println(i);
            System.out.println("first is "+first);
            if (i%2 == 0) {
                result[i] = letters[first];
                first--;
            } else {
                result[i] = letters[next];
                next++;
            }
        }
        System.out.println(result);
    }
}

import java.util.Scanner;

public class emne {

    public static  void main(String []args){

        Scanner scan=new Scanner(System.in);
        String s=scan.next();//ncteho

if(s.length()==1)
{
      System.out.println(s); System.exit(0);
}
        StringBuffer target =new StringBuffer(' ');

if(s.length()%2==0)
{
       for(int i=0;i<(s.length()/2);i++){

            target.append(s.charAt(s.length()-i-1));
             System.out.println(target);
            target.append(s.charAt(i));
           System.out.println(target);

        }
}
  else{
        int i;
             for(i=0;i<(s.length()/2);i++){

            target.append(s.charAt(i));
          //   System.out.println(target);
            target.append(s.charAt(s.length()-i-1));
          // System.out.println(target);

        }
        target.append(s.charAt(i));

      }

        target.reverse();
       // target.trimToSize();
        System.out.println(target);
    }

}

//jsonW0
//Java 8
import java.util.*;

public class RL_Cipher
{
   public static void main(String[] args)
   {
      Scanner input = new Scanner(System.in);
      String k = input.next();
      String orig = "";
      for(int a=0; k.length()!=0; a++) {
         orig = add(orig,k.substring(k.length()-1,k.length()));
         k = k.substring(0,k.length()-1);
         a++;
         if(k.length()!=0) {
            orig = add(orig, k.substring(0,1));
            k = k.substring(1);
         }
      }
      System.out.println(orig);
   }
   public static String add(String o, String k)
   {
      o = k + o;
      return o;
   }
}

import java.util.Scanner;
public class desc_y_ordenar_ascendentemente {
	public static void main(String[]args){
		Scanner leer=new Scanner(System.in);
		String cad=leer.next();
		System.out.println(cad);

	}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import java.util.*;

public class A_GENERAL {

	// for fast output printing  : use printwriter or stringbuilder
	// remember to close pw using pw.close()
	static StringBuilder sb = new StringBuilder();
	static long seive_size = (long) 1e6;
	static String alpha = "abcdefghijklmnopqrstuvwxyz";
    static ArrayList<Integer> primes = new ArrayList<>();
    static boolean[] seive_set = new boolean[(int) seive_size+1];
    static int n, m, k;
    static ArrayList<Integer>[] adj;
    static boolean[] vis;
//    static ArrayDeque<Integer> q = new ArrayDeque<>();
    static ArrayDeque<Pair> qq = new ArrayDeque<>();
    static final long MOD = 1000000007;
    static int[] dx = new int[] {1, 0, -1, 0, 1, -1, 1, -1};
    static int[] dy = new int[] {0, 1, 0, -1, -1, 1, 1, -1};
    static long[][] arr;
    static int[] rank;
    static int[] parent;

    public static void main(String[] args) throws FileNotFoundException {
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		MyScanner sc = new MyScanner();
		char[] s = sc.next().toCharArray();
		n = s.length;
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < s.length/2; i++) {
			sb.append(s[n-1-i]);
			sb.append(s[i]);
		}
		if(n%2 == 1) {
			sb.append(s[n/2]);
		}
		System.out.println(sb.reverse().toString());
		out.close();
	}
    public static class Triplet implements Comparable<Triplet> {
		int x;
    	int y;
    	int z;
    	Triplet(int x, int y, int z) {
    		this.x = x;
    		this.y = y;
    		this.z = z;
    	}
    	public int compareTo(Triplet o) {
    		return Integer.compare(this.x, o.x);
    	}
    }
    public static class Pair implements Comparable<Pair>  {
    	int f;
    	int s;
    	Pair(int f, int s) {
    		this.f = f;
    		this.s = s;
    	}
    	public int compareTo(Pair o) {
    		return Integer.compare(this.f,  o.f);
    	}
    }
	public static class LongPair implements Comparable<LongPair>{
		long f;
		long s;
		LongPair(long f, long s) {
			this.f = f;
			this.s = s;
		}
		public int compareTo(LongPair o) {
			return Long.compare(this.f, o.f);
		}
	}
	public static void init(int n) {
    	adj = new ArrayList[n+1];
    	vis = new boolean[n+1];
    	parent = new int[n+1];
		rank = new int[n+1];
    	for(int i = 0; i <= n; i++) {
    		adj[i] = new ArrayList<>();
    		parent[i] = i;
			rank[i] = 0;
    	}
    }
	// print string "s" multiple times
	// prefer to use this function for multiple printing
	public static String mp(String s, int times) {
		return String.valueOf(new char[times]).replace("\0", s);
	}
	// take log with base 2
 	public static long log2(long k) {
 		return 63-Long.numberOfLeadingZeros(k);
 	}

 	// using lambda function for sorting
   	public static void lambdaSort() {
   		Arrays.sort(arr, (a, b) -> Double.compare(a[0], b[0]));
   	}

  	// (n choose k) = (n/k) * ((n-1) choose (k-1))
  	public static long choose(long n, long k) {
 		return (k == 0) ? 1 : (n*choose(n-1, k-1))/k;
 	}

 	// just for keeping gcd function for other personal purposes
 	public static long gcd(long a, long b) {
 		return (a == 0) ? b : gcd(b%a, a);
 	}

	public static long max(long... as) {
        long max = Long.MIN_VALUE;
        for (long a : as) max = Math.max(a, max);
        return max;
    }

    public static long min(int... as) {
        long min = Long.MAX_VALUE;
        for (long a : as) min = Math.min(a, min);
        return min;
    }

    public static long modpow(long x, long n, long mod) {
    	if(n == 0) return 1%mod;
    	long u = modpow(x, n/2, mod);
    	u = (u*u)%mod;
    	if(n%2 == 1) u = (u*x)%mod;
    	return u;
    }
 	// ======================= binary search (lower and upper bound) =======================
	public static int lowerBound(long[] a, int x) {
		int lo = 0;
 		int hi = a.length-1;
 		int ans = -1;
 		while(lo <= hi) {
 			int mid = (lo+hi)/2;
 			if(x < a[mid]) {
 				hi = mid-1;
 			} else if(x > a[mid]) {
 				lo = mid+1;
 			} else if(lo != hi) {
 				 hi = mid-1; 		// for first occurrence
 				 ans = mid;
 			} else {
 				return mid;
 			}
 		}
 		return ans;
	}

	public static int upperBound(long[] a, long x) {
		int lo = 0;
		int hi = a.length-1;
		int ans = -1;
		while(lo <= hi) {
			int mid = (lo+hi)/2;
			if(x < a[mid]) {
				hi = mid-1;
			} else if(x > a[mid]) {
				lo = mid+1;
			} else if(lo != hi) {
				lo = mid+1;			// for last occurrence
				ans = mid;
			} else {
				return mid;
			}
		}
		return ans;
	}
	// ================================================================

	// ================== SEIVE OF ERATOSTHENES =======================
	// Complexity : O(N * log(log(N)))       ( almost O(N) )
	public static void generatePrimes() {
		// set.add(0);
		// set.add(1);
		Arrays.fill(seive_set, true);
		seive_set[0] = false;
		seive_set[1] = false;
		for(int i = 2; i <= seive_size; i++) {
			if(seive_set[i]) {
				for(long j = (long) i*i; j <= seive_size; j+=i)
					seive_set[(int)j] = false;
				primes.add(i);
			}
		}
	}

	public static boolean isPrime(long N) {
		if(N <= seive_size) return seive_set[(int)N];
		for (int i = 0; i < (int)primes.size(); i++)
			if (N % primes.get(i) == 0) return false;
		return true;
	}
	// ===========================================================

 	// ================ Permutation of String ====================
 	public static void permute(String str) {
 		permute(str, 0, str.length()-1);
 	}
 	public static void permute(String str, int l, int r)
    {
        if (l == r)
            System.out.println(str);
        else
        {
            for (int i = l; i <= r; i++)
            {
                str = swap(str,l,i);
                permute(str, l+1, r);
                str = swap(str,l,i);
            }
        }
    }
	public static String swap(String a, int i, int j)
    {
        char temp;
        char[] charArray = a.toCharArray();
        temp = charArray[i] ;
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return String.valueOf(charArray);
    }
	// Union-find
	// static int[] parent, rank;
//	public static void makeSet(int n) {
//
//		parent = new int[n+1];
//		rank = new int[n+1];
//		for(int i = 1; i <= n; i++) {
//			parent[i] = i;
//			rank[i] = 0;
//		}
//	}
	public static int find(int u) {

		if(parent[u] == u)	return u;

		int v = find(parent[u]);
		parent[u] = v;
		return v;

	}
	public static boolean connected(int u, int v) {
		return find(u) == find(v);
	}
	public static void Union(int u, int v) {

		int x = find(u);				//root of u
		int y = find(v);				//root of v

		if(x == y)		return;
		if(rank[x] == rank[y]) {
			parent[y] = x;
			rank[x]++;
		}
		else if(rank[x] > rank[y]) {
			parent[y] = x;
		}
		else {
			parent[x] = y;
		}

	}

//	public static int dijkstra(int x, int y) {
//    	int[] dist = new int[n+1];
//    	Arrays.fill(dist, Integer.MAX_VALUE);
//    	PriorityQueue<Node> q = new PriorityQueue<>();
//    	q.add(new Node(x, 0));
//    	dist[x] = 0;
//    	while(!q.isEmpty()) {
//    		Node node = q.poll();
//    		int u = node.key;
//    		if(u == y) {
//    			break;
//    		}
//    		for(int v : res[u]) {
//    			if(dist[v] > dist[u]+count[u]) {
//    				dist[v] = dist[u] + count[u];
//    				q.add(new Node(v, dist[v]));
//    			}
//    		}
//    	}
//    	if(dist[y] == Integer.MAX_VALUE) {
//    		return -1;
//    	}
//    	return dist[y];
//    }

	public static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		String next() {while (st == null || !st.hasMoreElements()) {
			try {st = new StringTokenizer(br.readLine());}
			catch (IOException e) {e.printStackTrace();}}
		return st.nextToken();}
		int nextInt() {return Integer.parseInt(next());}
		long nextLong() {return Long.parseLong(next());}
		double nextDouble() {return Double.parseDouble(next());}
		String nextLine(){String str = "";
		try {str = br.readLine();}
		catch (IOException e) {e.printStackTrace();}
		return str;}
		int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        int[] nextIntArray(int n, int delta) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt() + delta;
            return a;
        }

        long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
	}

}

import java.util.*;
import java.io.*;

public class Solution {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String str = scan.next();
		int n = str.length();
		StringBuilder ans = new StringBuilder();
		for(int i = 0; i < n; i++){
			ans.append(str.charAt(n-1-i));
			ans.append(str.charAt(i));
		}
		System.out.println(ans.substring(n));
		scan.close();
	}
}

import java.util.Scanner;

public class JavaApplication141 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String x = "erfdcoeocs";
        char c [] = new char[x.length()];
        int s = 0;

        if(x.length() % 2 == 0){
            for(int i= x.length()/2-1; i>=0; i--){
                c[s++] +=  x.charAt(i);
                c[s++] += x.charAt(x.length() - 1 - i);
            }
        }else{
            c[s++] = x.charAt(x.length()/2);
            for(int i=x.length()/2-1; i>=0; i--){
                c[s++] = x.charAt(x.length()-1-i);
                c[s++] = x.charAt(i);
            }
        }

        for(int i=0; i<x.length(); i++){
            System.out.print(c[i]);
        }

    }

}

import java.util.Scanner;
public class ciphers
{
    public static void main(String args[])
    {
        Scanner x= new Scanner(System.in);
        String s= x.nextLine();
        int n=s.length();
        int i, k=0;
        char c[]= new char[n];
        if(n==1)
        System.out.println(s);
        else
        {
        for(i=0; i<n/2; i++)
        {
            c[n-2-k]=s.charAt(i);
            c[n-1-k]=s.charAt(n-1-i);
            k=k+2;
        }
        for(i=0; i<n; i++)
        System.out.print(c[i]);
    }
    }
}

import java.util.*;
public class Main {
  public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    String k=s.next();
    int n=k.length();
    if(n%2==0)
    {
      String a=k.substring(0, n/2);
      String b=k.substring(n/2);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-1-i));
        System.out.print(b.charAt(i));
      }
    }
    else
    {
      String a=k.substring(0, n/2 +1);
      String b=k.substring(n/2 +1);
      System.out.println(b);
      for(int i=0;i<n/2;i++)
      {
        System.out.print(a.charAt(n/2-i));
        System.out.print(b.charAt(i));
      }
      System.out.print(a.charAt(0));
    }
  }
}

//package codeforcesa;
import java.util.*;
public class RightLeftCipher {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String t=in.nextLine();
        String s="";
        int index=0;

        if(t.length()%2==0)
        {
            index=t.length()/2 -1;
        }
        else
        {
            index=t.length()/2;
        }
        s=s+t.charAt(index);
        int count=1;
        int flag=0;
        for(int i=index;i<t.length()-1;)
        {
            if(flag==0)
            {
                flag=1;
                i=index+count;
                s=s+t.charAt(i);
            }
            else
            {
                flag=0;
                i=index-count;
                s=s+t.charAt(i);
                count++;
            }
        }
        System.out.println(s);
    }
}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;

public class george
{
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
 static int max(int a[],int n) {
	 int max=a[0];
	 int ind=0;
	 for(int i=1;i<n;i++) {
		 if(a[i]>=max) {
			 max=a[i];
			 ind=i;
		 }
	 }
	 return ind;
 }
 static int min(int a[],int n) {
	 int min=a[0];
	 int ind=0;
	 for(int i=1;i<n;i++) {
		 if(a[i]<min) {
			 min=a[i];
			 ind=i;
		 }
	 }
	 return ind;
 }
 static boolean fun(int i) {
	 for(int j=3;j<=20;j++) {
		 if(i%j!=0) {
			 return false;
		 }
	 }
	 return true;
 }
 static int bin(int arr[], int l, int r, int x)
 {
     if (r>=l)
     {
         int mid = l + (r - l)/2;

         if (arr[mid] == x)
            return mid;

         if (arr[mid] > x)
            return bin(arr, l, mid-1, x);
         return bin(arr, mid+1, r, x);
     }

     return -1;
 }
 static boolean isPalindrome(int n)
 {

     int divisor = 1;
     while (n / divisor >= 10)
         divisor *= 10;

     while (n != 0)
     {
         int leading = n / divisor;
         int trailing = n % 10;

         if (leading != trailing)
             return false;

         n = (n % divisor) / 10;

         divisor = divisor / 100;
     }
     return true;
 }
 public static String sortString(String inputString)
 {
     // convert input string to char array
     char tempArray[] = inputString.toCharArray();

     // sort tempArray
     Arrays.sort(tempArray);

     // return new sorted string
     return new String(tempArray);
 }
 public static boolean allDifferent( int[]a){
	    for(int i = 0; i < a.length; i++){
	        if(a[i] != 0){
	            return true;
	        }

	    }
	    return false;
}

    public static void main(String[] args) throws IOException
    {
        Reader s=new Reader();
        String st = s.readLine();
        char [] da = st.toCharArray();
//        if(st.length()<=2) {
//        	System.out.println(st);
//        	System.exit(0);
//        }
        int len = st.length()-2;
        int j=1;
        int ss=1;
        int r,l;
        r=l=(st.length()/2)-1;
        char ans[]=new char[st.length()];
        ans[0]=st.charAt((st.length()/2)-1);

        while(len>0) {
        	if(j%2==0) {
        		l--;
        		ans[ss]=da[l];
        	} else {

        		r++;

        		ans[ss]=da[r];
        	}
        	ss++;
        	j++;
        	len--;

        }
        StringBuilder sb = new StringBuilder();
		for (char ch: ans) {
			if(ch!=' ') {
			sb.append(ch);
			}
		}

        System.out.println(sb);
    }
}

import java.io.*;
import java.util.*;

public class Main {
    static class Reader {
        BufferedReader in;

        Reader() throws IOException {
            in = new BufferedReader(new InputStreamReader(System.in));
        }

        Reader(String name) throws IOException {
            in = new BufferedReader(new FileReader(name));
        }

        StringTokenizer tokin = new StringTokenizer("");

        String next() throws IOException {
            if (!tokin.hasMoreTokens()) {
                tokin = new StringTokenizer(in.readLine());
            }
            return tokin.nextToken();
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }

    static class Writer {
        PrintWriter cout;

        Writer() throws IOException {
            cout = new PrintWriter(System.out);
        }

        Writer(String name) throws IOException {
            cout = new PrintWriter(new FileWriter(name));
        }

        StringBuilder out = new StringBuilder();

        void print(Object a) {
            out.append(a);
        }

        void close() {
            cout.print(out.toString());
            cout.close();
        }
    }

    public static void main(String args[]) throws IOException {
        Reader in = new Reader();
        Writer out = new Writer();
        String s = in.next();
        if (s.length() % 2 == 1)
            out.print(s.charAt((s.length() - 1) / 2));
        for (int i = (s.length() - 2 - s.length() % 2) / 2; i > -1; i--) {
            out.print(s.charAt(i));
            out.print(s.charAt(s.length() - 1 - i));
        }
        out.close();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class A {

	public static void main(String[] args) {
		FastReader scan = new FastReader();
		char[] s = scan.next().toCharArray();
		if (s.length % 2 != 0)
			System.out.print(s[s.length / 2]);
		char[] a = new char[s.length / 2], b = new char[s.length / 2];
		for (int i = 0; i < s.length / 2; i++) {
			a[i] = s[s.length / 2 - 1 - i];
			b[i] = s[s.length / 2 + i + (s.length & 1)];
		}
		String res = "";
			for (int i = 0; i < s.length / 2; i++) {
				res += a[i] + "" +  b[i];
			}
		System.out.println(res);

	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

}

import java.util.*;

public class main
{
       public static void main(String args[])
       {
              Scanner sc=new Scanner(System.in);
              String s=sc.next();
              String st="";
              String x="";
              String y="";
              int pos=0;
              if(s.length()%2==0)
              {   pos=s.length()/2;
                     for(int i=pos-1;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
              }

              else
              {
                     pos=(s.length()/2);
                     for(int i=pos;i>=0;i--)
                     {
                            x+=s.charAt(i);
                     }
                     for(int i=pos+1;i<s.length();i++)
                     {
                            y+=s.charAt(i);
                     }
                     for(int i=0,j=0;i<x.length() && j<y.length();i++,j++)
                     {
                            st+=x.charAt(i);
                            st+=y.charAt(j);
                     }
                     if(x.length()>y.length())
                     {
                            st+=x.charAt(x.length()-1);
                     }
                     else
                     {
                            st+=y.charAt(y.length()-1);
                     }

              }
              System.out.println("String is: "+st);
       }
}

import java.util.Scanner;

public class CF1085A {

	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		char[] ch = sc.next().toCharArray();
		char[] res = new char[ch.length];
		int c = ch.length/2;
		int w = 0;
		for(int i = 0; i < c; i++){
			if (c-i-1 >= 0) res[w++] = ch[c-i-1];
			res[w++] = ch[i+c];

		}
		//ncteho

		System.out.println(new String(res));
	}
}

import java.util.Scanner;

public class RightLeftCipher {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        StringBuilder sb = new StringBuilder();
        if(s.length()==1){
            System.out.println(s);
        }
        int index = (int)Math.ceil(s.length() / (double)2) -1;
        sb.append(s.charAt(index));
        for (int i = 1; i < s.length(); i++) {
            if(i%2==0){
                index = index - i;
            }else {
                index = index + i;
            }
            sb.append(s.charAt(index));
        }
        System.out.println(sb);
    }
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Scanner in =new Scanner(System.in);
		String s=in.next();
		int n=s.length();
		if (n%2==1)
	{String u="";
	for(int i=0;i<(((n-1)/2)+1);i++)
	{
		if (i!=((n-1)/2))

		{	u=""+(char)s.charAt(n-1-i)+""+(char)s.charAt(i)+""+u;}
		else
			{u=""+(char)s.charAt(i)+""+u;}
	System.out.println(u);
	}   }
else
{
	String u="";
	for (int i=0;i<n/2;i++)
	{
		u=""+(char)s.charAt(i)+""+(char)s.charAt(n-1-i)+""+u;}
	System.out.print(u);

	}
}
}

/*****Author: Satyajeet Singh, Delhi Technological University************************************/
    import java.io.*;
    import java.util.*;
    import java.text.*;
    import java.lang.*;
    import java.math.*;
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 ArrayList<Integer> graph[];
    static int pptr=0,pptrmax=0;
    static String st[];
/*****************************************Solution Begins***************************************/
    public static void main(String args[]) throws Exception{
        String str=ps();
        String ans="";
        int i=0,j=str.length()-1;
        while(i<=j){
            if(i>j)break;
            ans=str.charAt(j)+ans;
            j--;
            if(i>j)break;
            ans=str.charAt(i)+ans;
            i++;
        }
        out.println(ans);
/****************************************Solution Ends**************************************************/
        out.flush();
        out.close();
    }
/****************************************Template Begins************************************************/
    static void nl() throws Exception{
        pptr=0;
        st=br.readLine().split(" ");
        pptrmax=st.length;
    }
    static void nls() throws Exception{
        pptr=0;
        st=br.readLine().split("");
        pptrmax=st.length;
    }
    static int pi() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Integer.parseInt(st[pptr++]);
    }
    static long pl() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Long.parseLong(st[pptr++]);
    }
    static double pd() throws Exception{
        if(pptr==pptrmax)
            nl();
        return Double.parseDouble(st[pptr++]);
    }
    static String ps() throws Exception{
        if(pptr==pptrmax)
            nl();
        return st[pptr++];
    }
/***************************************Precision Printing**********************************************/
    static void printPrecision(double d){
        DecimalFormat ft = new DecimalFormat("0.0000000000");
        out.println(ft.format(d));
    }
/**************************************Bit Manipulation**************************************************/
    static int countBit(long mask){
        int ans=0;
        while(mask!=0){
            mask&=(mask-1);
            ans++;
        }
        return ans;
    }
/******************************************Graph*********************************************************/
    static void Makegraph(int n){
        graph=new ArrayList[n];
        for(int i=0;i<n;i++)
            graph[i]=new ArrayList<>();
    }
    static void addEdge(int a,int b){
        graph[a].add(b);
    }
    // static void addEdge(int a,int b,int c){
    //     graph[a].add(new Pair(b,c));
    // }
/*********************************************PAIR********************************************************/
    static class Pair{
        int u;
        int v;
        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 String toString() {
            return "[u=" + u + ", v=" + v + "]";
        }
    }
/******************************************Long Pair*******************************************************/
    static class Pairl{
        long u;
        long v;
        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) {
            Pairl other = (Pairl) o;
            return u == other.u && v == other.v;
        }
        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,y=a%c;
        while(b > 0){
            if(b%2 == 1)
                x=(x*y)%c;
            y = (y*y)%c;
            b = b>>1;
        }
        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;
        b = (x < y) ? x : y;
        r = b;
        while(a % b != 0){
            r = a % b;
            a = b;
            b = r;
        }
        return r;
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class shifrow {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String s1 = s.nextLine();
        ArrayList<Character> l = new ArrayList();
        for (int i=0;i<s1.length();i++){
            l.add(s1.charAt(i));
        }
        String ans="";
        while (l.size()!=0){
            ans+=l.get((l.size()-1)/2);
            l.remove((l.size()-1)/2);
            if (l.size()==0) break;
            ans+=l.get((l.size()+1)/2-1);
            l.remove((l.size()+1)/2-1);
        }

        System.out.println(ans);
    }
}

import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer("");
    PrintWriter pw = new PrintWriter(System.out);

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    String next() throws IOException {
        if (!st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public Main() throws FileNotFoundException {
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }

    long mod = (long) 1e9 + 7;

    void run() throws IOException {
        char[] a = next().toCharArray();
        if (a.length % 2 == 0) {
            ArrayList<Character> ans = new ArrayList<>();
            int x = 0;
            while (x < a.length / 2) {
                ans.add(a[a.length - 1 - x]);
                ans.add(a[x]);
                x++;
            }
            for (int i = ans.size() - 1; i >= 0; i--) {
                pw.print(ans.get(i));
            }
        } else {
            ArrayList<Character> ans = new ArrayList<>();
            int x = 0;
            while (x < a.length / 2) {
                ans.add(a[a.length - 1 - x]);
                ans.add(a[x]);
                x++;
            }
            ans.add(a[a.length / 2]);
            for (int i = ans.size() - 1; i >= 0; i--) {
                pw.print(ans.get(i));
            }

        }
        pw.close();
    }

    class Pair {
        int x, y;

        public Pair(int a, int b) {
            x = a;
            y = b;
        }
    }

    class PairComp implements Comparator<Pair> {

        @Override
        public int compare(Pair o1, Pair o2) {
            if (o1.x == o2.x) return Integer.compare(o1.y, o2.y);
            return Integer.compare(o1.x, o2.x);
        }
    }
}

// 作者：杨成瑞先生
import java.io.*;
import java.util.*;

public class cipher {
	public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String encryption = br.readLine();
        String decryption = "";

        int len = encryption.length();

        if(len == 1) {
            System.out.println(encryption);
            return;
        }

        int middle = (len / 2) - 1;

        decryption += encryption.charAt(middle);
        //System.out.println(decryption);

        int i = middle + 1;
        int j = middle - 1;

        while(decryption.length() != len) {
            if(i < len) {
                decryption += encryption.charAt(i);
            }
            if(j >= 0) {
                decryption += encryption.charAt(j);
            }
            i++;
            j--;
        }

        System.out.println(decryption);
	}
}

import java.util.*;
public class A{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String s = scan.next();
		int n = s.length();
		int i = 0,j = n-1;
		StringBuilder ans =  new StringBuilder();
		while(i < j)
		{
			ans.append(s.charAt(j));
			ans.append(s.charAt(i));
			i++;j--;
		}
		if(n%2 == 1)
			ans.append(s.charAt(i));
		System.out.println(ans.reverse());
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner cin = new Scanner(System.in);

		String str = cin.next();

		String nrstr = "";

		int l = 0;
		int r = 0;
		boolean b = false;

		if (str.length() % 2 == 0 || str.length() <= 3) {

			for (int i = 0; i < str.length(); i++) {

				if (b == false) {

					nrstr += str.charAt(str.length() - 1 - r);
					r++;
					b = true;

				} else {

					nrstr += str.charAt(l);
					l++;
					b = false;

				}

			}

			String result = "";

			for (int i = 0; i < str.length(); i++) {

				result += nrstr.charAt(str.length() - 1 - i);

			}

			System.out.println(result);

		} else {

			for (int i = 0; i < str.length(); i++) {

				if (b == true) {

					nrstr += str.charAt(str.length() - 1 - r);
					r++;
					b = false;

				} else {

					nrstr += str.charAt(l);
					l++;
					b = true;

				}

			}

			String result = "";

			for (int i = 0; i < str.length(); i++) {

				result += nrstr.charAt(str.length() - 1 - i);

			}

			System.out.println(result);

		}

	}

}

import java.io.*;
import java.util.*;

public class cf123A{
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s = br.readLine();

		if(s.length()<=2) {
			System.out.println(s);
			return;
		}

		int l = s.length()-1;
		int mid = l/2;
		int i=mid-1;
		int j=mid+1;
		System.out.println(s.charAt(mid));
		while(i>=0 && j<s.length()) {
			System.out.println(s.charAt(j));
			j++;
			System.out.println(s.charAt(i));
			i--;
		}

		if(j<s.length()) {
			System.out.println(s.charAt(j));
		}

	}
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        String str = "";
        boolean boo = true;
        while(!s.equals("")){
            if(boo) {
                str += s.charAt(s.length() - 1);
                s = s.substring(0, s.length() - 1);
                boo = !boo;
            } else {
                str += s.charAt(0);
                s = s.substring(1);
                boo = !boo;
            }
        }
        System.out.print(new StringBuffer(str).reverse());
    }
}

import java.util.*;
public class RLC{
	public static void main(String args[])
	{
		Scanner in = new Scanner(System.in);
		String s = in.nextLine();
		String o = new String();
		//techno
		//ncteho
		if(s.length() == 1)
		{
			System.out.println(s);
		}
		else
		{
			for(int i = 0 ; i < s.length()/2; i++)
			{
				if(s.length()%2 == 0)
				{
						o = s.charAt(s.length() - i - 1) + o;
						o = s.charAt(i) + o;
				}
				else
				{
					o = s.charAt(i) + o;
					o = s.charAt(s.length() - i - 1) + o;
				}

			}
			System.out.println(o);
		}
	}
}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        char[] chars = scanner.next().toCharArray();
        int a = 0;

        int c = chars.length;
        StringBuilder s = new StringBuilder();
        while(c>0){
            s.append(chars[chars.length - 1 - a]);
            s.append(chars[a]);
            a++;
            c-=2;
        }
        StringBuilder s2 = new StringBuilder();

        for (int i = s.length()-1; i >= 0; i--) {
            s2.append(s.charAt(i));
        }

        System.out.println(s2.toString());

    }
}

import java.util.Collections;
import java.util.Scanner;
import java.util.Vector;

public class Main {

	public static void main(String[] args) {

		Scanner in=new Scanner(System.in);

		String dec=null;

		dec=in.next();

		int oddvalue=(dec.length()-1)/2;

		int evenvalue=oddvalue+1;

		// 4   1    5

		Vector<String> oddvalues=new Vector();
	String enc=dec.substring(oddvalue,oddvalue+1);
	for(int i=0;i<oddvalue;i++)
	{

		oddvalues.add(dec.substring(i,i+1));

	}
	Vector<String> evenvalues=new Vector<>();
	for(int i=oddvalue+1;i<dec.length();i++)
	{

		evenvalues.add(dec.substring(i,i+1));

	}

Collections.reverse(oddvalues);

	int c1=0,c2=0;
	for(int i=0;i<dec.length()-1;i++)
	{

		if(true)
		{
			if(i%2==0&&c1<evenvalues.size())
			{

				enc+=evenvalues.get(c1++).toString();

			}
			else if(i%2==1&&c2<oddvalues.size())
			{
				enc+=oddvalues.get(c2++).toString();
			}
			System.out.println(enc);
		}
	}
	System.out.println(enc);

	}

}

import java.io.*;
import java.lang.reflect.Array;
import java.util.*;

public class Main{
    public static void main(String[] args)throws IOException {
        FastReader in = new FastReader();
        OutputStream output = System.out;
        PrintWriter out = new PrintWriter(output);
        String s = in.next();
        int lenght = s.length();
        StringBuilder sb = new StringBuilder();
        int ind = (lenght / 2) - 1;
        if (ind < 0) {
            out.println(s);
        } else {
            sb.append(s.charAt(ind));
            int i = 1, j = -1;
            while (true) {
                if ((ind + i) < lenght) {
                    sb.append(s.charAt(ind + i));
                    i++;
                }
                if ((ind + j) >= 0) {
                    sb.append(s.charAt(ind + j));
                    j--;
                } else {
                    break;
                }
            }
            out.println(sb);
        }
        out.close();
    }
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.*;
public class Main
{
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		String st=s.nextLine();
		String en="";
		char ch []=st.toCharArray();
		int r=ch.length-1;
		int l=0;
	//	System.out.println(l);
	//System.out.println(r);
	if(l==r)
	System.out.println(st);

		while(l<r)
		{
		    en=st.charAt(r)+en;
		    en=st.charAt(l)+en;
		    l++;
		    r--;
		}
		System.out.println(en);
	}
}

// "static void main" must be defined in a public class.
import java.util.*;
import java.io.*;
import java.lang.*;
public class Main {
    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String ans ="";
        int x =0;
        while(s.length()>0){
            char z = x==0?s.charAt(s.length()-1):s.charAt(0);
            if(x==0)
                s=s.substring(0,s.length()-1);
            else
                s=s.substring(1);
            ans = z+ans;
            x=~x;
        }
        System.out.println(ans);
    }
}

//package yahia;
import java.io.PrintWriter;
import java.util.*;public class Main {public static void main (String []args) {Scanner sc =new Scanner (System.in);
String w =sc.next();char [] x =w.toCharArray();int a =x.length;String j ="";
if (a<=2) System.out.println(w);
else {
	j=j+x[a/2-1]+x[a/2];
	int i =(a-2)/2 -1;int s =a/2+1;
	while (i>0||s<a) {
		if (i>=0) {
			j=j+x[i];
			--i;
		}
		j=j+x[s];++s;
	}
	System.out.println(j);

}}}