import java.util.*; // for tests in main()

/*
 * get() and put() after: https://algs4.cs.princeton.edu/code/edu/princeton/cs/algs4/RedBlackBST.java.html
 */

public class RedBlackBST<Key extends Comparable<Key>, Val> {
        private static final boolean RED = true, BLACK = false;

        private Node root;

        private class Node {
                private Key      key;
                private Val      val;
                private Node     lft, rgt;
                private boolean  rob;
                private int      num;

                public Node(Key key, Val val) {
                        this.key = key;
                        this.val = val;
                        this.rob = RED;
                        this.num = 1;
                }
        }

        public RedBlackBST() {}

        private boolean isRed(Node tree) {
                if (tree == null)
                        return false;
                return tree.rob == RED;
        }
        private boolean isBlack(Node tree) {
                return !isRed(tree);
        }

        private int size(Node tree) {
                if (tree == null)
                        return 0;
                return tree.num;
        }

        private void update_size(Node tree) {
                tree.num = size(tree.lft) + size(tree.rgt) + 1;
        }

        private Node rotate_right(Node tree) {
                assert(tree != null && isRed(tree.lft));

                Node p = tree.lft;
                tree.lft = p.rgt;
                p.rgt = tree;
                p.rob = p.rgt.rob;
                p.rgt.rob = RED;
                p.num = tree.num;
                update_size(tree);
                return p;
        }

        private Node rotate_left(Node tree) {
                assert(tree != null && isRed(tree.rgt));

                Node p = tree.rgt;
                tree.rgt = p.lft;
                p.lft = tree;
                p.rob = p.lft.rob;
                p.lft.rob = RED;
                p.num = tree.num;
                update_size(tree);
                return p;
        }

        private void flip_colors(Node tree) {
                assert(tree != null);
                assert(tree.rgt != null && tree.lft != null);
                assert((isRed(tree) && isBlack(tree.lft) && isBlack(tree.rgt)) ||
                       (isBlack(tree) && isRed(tree.lft) && isRed(tree.rgt)));
                // for add(), always tree = black, left = red, right = red

                tree.rob = !tree.rob;
                tree.lft.rob = !tree.lft.rob;
                tree.rgt.rob = !tree.rgt.rob;
        }

        private Node put(Node tree, Key key, Val val) {
                if (tree == null)
                        return new Node(key, val);

                int cmp = key.compareTo(tree.key);
                if (cmp < 0)
                        tree.lft = put(tree.lft, key, val);
                else if (cmp > 0)
                        tree.rgt = put(tree.rgt, key, val);
                else
                        tree.val = val;

                if (isRed(tree.rgt) && isBlack(tree.lft))
                        tree = rotate_left(tree);
                if (isRed(tree.lft) && isRed(tree.lft.lft))
                        tree = rotate_right(tree);
                if (isRed(tree.lft) && isRed(tree.rgt))
                        flip_colors(tree);
                update_size(tree);
                return tree;
        }

        public void put(Key key, Val val) {
                root = put(root, key, val);
                root.rob = BLACK;
        }

        private Val get(Node tree, Key key) {
                while (tree != null) {
                        int cmp = key.compareTo(tree.key);

                        if (cmp < 0)
                                tree = tree.lft;
                        else if (cmp > 0)
                                tree = tree.rgt;
                        else
                                return tree.val;
                }
                return null;
        }

        public Val get(Key key) {
                return get(root, key);
        }

        public static void main(String[] args) {
                int n = Integer.parseInt(args[0]);

                Map<Integer, Integer> ht = new HashMap<>();
                RedBlackBST<Integer, Integer> bt = new RedBlackBST<>();

                for (int i = 0; i < n; i++) {
                        Integer k;
                        Integer v = (int)(Math.random() * 1000000000);

                        do {
                                k = (int)(Math.random() * 1000000000);
                        } while (ht.containsKey(k));
                        ht.put(k, v);
                        bt.put(k, v);
                }

                int count = 0;
                for (Map.Entry<Integer, Integer> pair: ht.entrySet()) {
                        Integer v = bt.get(pair.getKey());

                        if (v != null && pair.getValue().compareTo(v) == 0)
                                ++count;
                }
                System.out.println(count);
        }
}