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

public class Main {

    /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    }

    /**
     * あみだくじを表すクラス
     *
     */
    static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    }

    /**
     * 横棒を表すクラス
     *
     */
    static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    }
} import java.io.BufferedReader; BufferedReader java.io import java.io.IOException; IOException java.io import java.io.InputStreamReader; InputStreamReader java.io public class Main {

    /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    }

    /**
     * あみだくじを表すクラス
     *
     */
    static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    }

    /**
     * 横棒を表すクラス
     *
     */
    static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    }
} Main /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    } main {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    } Lots lots = readLots(); lots readLots() readLots int[] resultArray = new int[lots.numberOfVerticalLine]; resultArray new int[lots.numberOfVerticalLine] lots.numberOfVerticalLine lots lots.numberOfVerticalLine for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        } int i = 1; int i = 1; i 1 i <= lots.numberOfVerticalLine i lots.numberOfVerticalLine lots lots.numberOfVerticalLine i++ i++ i {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        } {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        } int result = i; result i for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            } HorizontalLine horizontalLine lots.getHorizontalLineArray() lots.getHorizontalLineArray lots {
                result = horizontalLine.jumpIfOnThisLine(result);
            } {
                result = horizontalLine.jumpIfOnThisLine(result);
            } result = horizontalLine.jumpIfOnThisLine(result) result horizontalLine.jumpIfOnThisLine(result) horizontalLine.jumpIfOnThisLine horizontalLine result resultArray[result - 1] = i resultArray[result - 1] resultArray result - 1 result 1 i for (int result : resultArray) {
            System.out.println(result);
        } int result resultArray {
            System.out.println(result);
        } {
            System.out.println(result);
        } System.out.println(result) System.out.println System.out System System.out result String[] args args /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    } readLots {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    } BufferedReader reader = new BufferedReader(new InputStreamReader(
                System.in)); reader new BufferedReader(new InputStreamReader(
                System.in)) int numberOfVerticalLine = Integer.parseInt(reader.readLine()); numberOfVerticalLine Integer.parseInt(reader.readLine()) Integer.parseInt Integer reader.readLine() reader.readLine reader int numberOfHorizontalLine = Integer.parseInt(reader.readLine()); numberOfHorizontalLine Integer.parseInt(reader.readLine()) Integer.parseInt Integer reader.readLine() reader.readLine reader HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine]; horizontalLineArray new HorizontalLine[numberOfHorizontalLine] numberOfHorizontalLine for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        } int i = 0; int i = 0; i 0 i < horizontalLineArray.length i horizontalLineArray.length horizontalLineArray horizontalLineArray.length i++ i++ i {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        } {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        } String[] numbers = reader.readLine().split(","); numbers reader.readLine().split(",") reader.readLine().split reader.readLine() reader.readLine reader "," int left = Integer.parseInt(numbers[0]); left Integer.parseInt(numbers[0]) Integer.parseInt Integer numbers[0] numbers 0 int right = Integer.parseInt(numbers[1]); right Integer.parseInt(numbers[1]) Integer.parseInt Integer numbers[1] numbers 1 horizontalLineArray[i] = new HorizontalLine(left, right) horizontalLineArray[i] horizontalLineArray i new HorizontalLine(left, right) if (reader != null) {
            reader.close();
        } reader != null reader null {
            reader.close();
        } reader.close() reader.close reader Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray); lots new Lots(numberOfVerticalLine, horizontalLineArray) return lots; lots static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    } Lots /** 縦棒の数 */
        int numberOfVerticalLine; numberOfVerticalLine /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray; horizontalLineArray /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        } Lots {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        } this.numberOfVerticalLine = numberOfVerticalLine this.numberOfVerticalLine this this.numberOfVerticalLine numberOfVerticalLine this.horizontalLineArray = horizontalLineArray this.horizontalLineArray this this.horizontalLineArray horizontalLineArray int numberOfVerticalLine numberOfVerticalLine HorizontalLine[] horizontalLineArray horizontalLineArray public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        } getNumberOfVerticalLine {
            return numberOfVerticalLine;
        } return numberOfVerticalLine; numberOfVerticalLine public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        } setNumberOfVerticalLine {
            this.numberOfVerticalLine = numberOfVerticalLine;
        } this.numberOfVerticalLine = numberOfVerticalLine this.numberOfVerticalLine this this.numberOfVerticalLine numberOfVerticalLine int numberOfVerticalLine numberOfVerticalLine public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        } getHorizontalLineArray {
            return horizontalLineArray;
        } return horizontalLineArray; horizontalLineArray public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        } setHorizontalLineArray {
            this.horizontalLineArray = horizontalLineArray;
        } this.horizontalLineArray = horizontalLineArray this.horizontalLineArray this this.horizontalLineArray horizontalLineArray HorizontalLine[] horizontalLineArray horizontalLineArray static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    } HorizontalLine /** 左端 */
        private int left; left /** 右端 */
        private int right; right /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        } HorizontalLine {
            this.left = left;
            this.right = right;
        } this.left = left this.left this this.left left this.right = right this.right this this.right right int left left int right right /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        } jumpIfOnThisLine {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        } if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            } value == right value right {
                return left;
            } return left; left if (value == left) {
                return right;
            } value == left value left {
                return right;
            } return right; right return value; value int value value public class Main {

    /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    }

    /**
     * あみだくじを表すクラス
     *
     */
    static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    }

    /**
     * 横棒を表すクラス
     *
     */
    static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    }
} public class Main {

    /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    }

    /**
     * あみだくじを表すクラス
     *
     */
    static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    }

    /**
     * 横棒を表すクラス
     *
     */
    static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    }
} Main
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    /**
     * あみだくじの情報を受け取り、その結果を表示する。
     *
     * @param args
     */
    public static void main(String[] args) throws IOException {

        // 入力値を受け取る
        Lots lots = readLots();

        // あみだくじを左から順番に実施する
        int[] resultArray = new int[lots.numberOfVerticalLine];
        for (int i = 1; i <= lots.numberOfVerticalLine; i++) {
            int result = i;

            // 横棒すべてに対してジャンプできるかどうか判定する
            for (HorizontalLine horizontalLine : lots.getHorizontalLineArray()) {
                result = horizontalLine.jumpIfOnThisLine(result);
            }

            // 最終的にどこに着いたかを保持する
            resultArray[result - 1] = i;
        }

        // 結果を出力する
        for (int result : resultArray) {
            System.out.println(result);
        }

    }

    /**
     * 標準入力から空白区切りの数値を取得し、三角形を表す数値の2次元配列として返却する。
     *
     * @return 三角形を表す整数の2次元配列（6×データ数）
     */
    protected static Lots readLots() throws IOException {

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

        // 最初に縦棒の数、横棒の数を取得する
        int numberOfVerticalLine = Integer.parseInt(reader.readLine());
        int numberOfHorizontalLine = Integer.parseInt(reader.readLine());

        // 1行につき、横棒の接続位置を表す2データを取り込む
        HorizontalLine[] horizontalLineArray = new HorizontalLine[numberOfHorizontalLine];
        for (int i = 0; i < horizontalLineArray.length; i++) {
            String[] numbers = reader.readLine().split(",");
            int left = Integer.parseInt(numbers[0]);
            int right = Integer.parseInt(numbers[1]);
            horizontalLineArray[i] = new HorizontalLine(left, right);
        }

        if (reader != null) {
            reader.close();
        }

        // 入力値をクラスにまとめて返却する
        Lots lots = new Lots(numberOfVerticalLine, horizontalLineArray);
        return lots;
    }

    /**
     * あみだくじを表すクラス
     *
     */
    static class Lots {

        /** 縦棒の数 */
        int numberOfVerticalLine;

        /** 横棒を表すペア数字の配列 */
        HorizontalLine[] horizontalLineArray;

        /**
         * コンストラクタ
         *
         * @param numberOfVerticalLine 縦棒の数
         * @param horizontalLineArray 横棒を表すペア数字の配列
         */
        public Lots(int numberOfVerticalLine, HorizontalLine[] horizontalLineArray) {
            this.numberOfVerticalLine = numberOfVerticalLine;
            this.horizontalLineArray = horizontalLineArray;
        }

        public int getNumberOfVerticalLine() {
            return numberOfVerticalLine;
        }

        public void setNumberOfVerticalLine(int numberOfVerticalLine) {
            this.numberOfVerticalLine = numberOfVerticalLine;
        }

        public HorizontalLine[] getHorizontalLineArray() {
            return horizontalLineArray;
        }

        public void setHorizontalLineArray(HorizontalLine[] horizontalLineArray) {
            this.horizontalLineArray = horizontalLineArray;
        }
    }

    /**
     * 横棒を表すクラス
     *
     */
    static class HorizontalLine {

        /** 左端 */
        private int left;

        /** 右端 */
        private int right;

        /**
         * コンストラクタ
         *
         * @param left 左端
         * @param right 右端
         */
        public HorizontalLine(int left, int right) {
            this.left = left;
            this.right = right;
        }

        /**
         * 横棒の上にある場合はもう一方に飛び、飛んだ先の番号を取得する。
         *
         * @param value 元の値
         * @return 飛べる場合は飛んだ先、飛べなかった場合は元の値
         */
        public int jumpIfOnThisLine(int value) {
            if (value == right) {
                return left;
            }
            else if (value == left) {
                return right;
            }
            return value;
        }
    }
}