import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    }

    static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    }

    static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    }
} import java.util.Scanner; Scanner java.util public class Main {
    public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    }

    static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    }

    static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    }
} Main public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    } main {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    } LimitInput limit = LimitInput.getInstance(); limit LimitInput.getInstance() LimitInput.getInstance LimitInput Input input = Input.getInstance(); input Input.getInstance() Input.getInstance Input Scanner sc = new Scanner(System.in); sc new Scanner(System.in) String sResult = ""; sResult "" limit.setLimit(Integer.parseInt(sc.next())) limit.setLimit limit Integer.parseInt(sc.next()) Integer.parseInt Integer sc.next() sc.next sc input.setInput((sc.next())) input.setInput input (sc.next()) sc.next sc final String sInput = input.getInput(); sInput input.getInput() input.getInput input final int iLimit = limit.getLimit(); iLimit limit.getLimit() limit.getLimit limit if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        } iLimit < sInput.length() iLimit sInput.length() sInput.length sInput {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } input.setSubStrInput(sInput.substring(0, iLimit)) input.setSubStrInput input sInput.substring(0, iLimit) sInput.substring sInput 0 iLimit sResult = input.addLimitOverVal(input.getSubStrInput()) sResult input.addLimitOverVal(input.getSubStrInput()) input.addLimitOverVal input input.getSubStrInput() input.getSubStrInput input {
            sResult = sInput;
        } sResult = sInput sResult sInput System.out.print(sResult) System.out.print System.out System System.out sResult String[] args args static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    } LimitInput private int m_iLimit; m_iLimit private static LimitInput m_Me = null; m_Me null private LimitInput() {
            m_iLimit = 0;

        } LimitInput {
            m_iLimit = 0;

        } m_iLimit = 0 m_iLimit 0 private int getLimit() {
            return m_iLimit;
        } getLimit {
            return m_iLimit;
        } return m_iLimit; m_iLimit private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        } setLimit {
            m_iLimit = iLimitInput;
        } m_iLimit = iLimitInput m_iLimit iLimitInput final int iLimitInput iLimitInput public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        } getInstance {
            return m_Me = new LimitInput();
        } return m_Me = new LimitInput(); m_Me = new LimitInput() m_Me new LimitInput() static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    } Input private static final String ADD_STR_VAL = "..."; ADD_STR_VAL "..." private String m_sInput; m_sInput private String m_sSubStrInput; m_sSubStrInput private static Input m_Me = null; m_Me null Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        } Input {
            m_sInput = "";
            m_sSubStrInput = "";
        } m_sInput = "" m_sInput "" m_sSubStrInput = "" m_sSubStrInput "" private void setInput(final String sInput) {
            m_sInput = sInput;
        } setInput {
            m_sInput = sInput;
        } m_sInput = sInput m_sInput sInput final String sInput sInput private String getInput() {
            return m_sInput;
        } getInput {
            return m_sInput;
        } return m_sInput; m_sInput private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        } setSubStrInput {
            m_sSubStrInput = sSubStrInput;
        } m_sSubStrInput = sSubStrInput m_sSubStrInput sSubStrInput final String sSubStrInput sSubStrInput private String getSubStrInput() {
            return m_sSubStrInput;
        } getSubStrInput {
            return m_sSubStrInput;
        } return m_sSubStrInput; m_sSubStrInput private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        } addLimitOverVal {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        } StringBuilder sb = new StringBuilder(); sb new StringBuilder() sb.append(sInput) sb.append sb sInput sb.append(ADD_STR_VAL) sb.append sb ADD_STR_VAL return sb.toString(); sb.toString() sb.toString sb final String sInput sInput public static Input getInstance() {
            return m_Me = new Input();
        } getInstance {
            return m_Me = new Input();
        } return m_Me = new Input(); m_Me = new Input() m_Me new Input() public class Main {
    public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    }

    static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    }

    static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    }
} public class Main {
    public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    }

    static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    }

    static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    }
} Main
import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws Exception {
        LimitInput limit = LimitInput.getInstance();
        Input input = Input.getInstance();
        Scanner sc = new Scanner(System.in);
        String sResult = "";

        // Int変換することで速度向上
        limit.setLimit(Integer.parseInt(sc.next()));
        input.setInput((sc.next()));

        final String sInput = input.getInput();
        final int iLimit = limit.getLimit();
        if (iLimit < sInput.length()) {
            input.setSubStrInput(sInput.substring(0, iLimit));
            sResult = input.addLimitOverVal(input.getSubStrInput());
        } else {
            sResult = sInput;
        }

        System.out.print(sResult);

    }

    static class LimitInput {

        private int m_iLimit;

        private static LimitInput m_Me = null;

        private LimitInput() {
            m_iLimit = 0;

        }

        private int getLimit() {
            return m_iLimit;
        }

        private void setLimit(final int iLimitInput) {
            m_iLimit = iLimitInput;
        }

        public static LimitInput getInstance() {
            return m_Me = new LimitInput();
        }
    }

    static class Input {

        private static final String ADD_STR_VAL = "...";

        private String m_sInput;
        private String m_sSubStrInput;
        private static Input m_Me = null;

        Input() {
            m_sInput = "";
            m_sSubStrInput = "";
        }

        private void setInput(final String sInput) {
            m_sInput = sInput;
        }

        private String getInput() {
            return m_sInput;
        }

        private void setSubStrInput(final String sSubStrInput) {
            m_sSubStrInput = sSubStrInput;
        }

        private String getSubStrInput() {
            return m_sSubStrInput;
        }

        private String addLimitOverVal(final String sInput) {
            StringBuilder sb = new StringBuilder();
            sb.append(sInput);
            sb.append(ADD_STR_VAL);
            return sb.toString();
        }

        public static Input getInstance() {
            return m_Me = new Input();
        }

    }
}
