Problem:
Score: 200 points

Problem Statement

The number 105 is quite special - it is odd but still it has eight divisors.
Now, your task is this: how many odd numbers with exactly eight positive divisors are there between 1 and N (inclusive)?

Constraints

N is an integer between 1 and 200 (inclusive).

Input

Input is given from Standard Input in the following format:

N

Output

Print the count.

Sample Input 1

105

Sample Output 1

1

Among the numbers between 1 and 105, the only number that is odd and has exactly eight divisors is 105.

Sample Input 2

7

Sample Output 2

0

1 has one divisor. 3, 5 and 7 are all prime and have two divisors. Thus, there is no number that satisfies the condition.

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

namespace Astar {
    /*class Node {
        Node((int x, int y) _pos, int _status, int _cost, int _h, int _score, Node node) {
            pos = _pos;
            status = _status;
            cost = _cost;
            h = _h;
            score = _score;
            parent = node;
        }
        public (int x, int y) pos;
        public int status;
        public int cost;
        public int h;
        public int score;
        public Node parent;
    }*/

    /*
    class Program
    {
        static Node AddNode(int dx, int dy, int H, int W, int X, Node node, List<List<string>> s) {
            if (node.pos.x + dx < 0 || node.pos.y + dy < 0
                || node.pos.x + dx >= W || node.pos.y + dy >= H) return null;
            int cost;
            int status;
            switch(s[node.pos.y + dy][node.pos.x + dx]) {
                case ".":
                    cost = 1;
                    status = 0;
                    break;
                case "S":
                    cost = 1;
                    status = 1;
                    break;
                case "G":
                    cost = 1;
                    status = 2;
                    break;
                case "#":
                    cost = X;
                    status = 0;
                    break;
            }
            Node result = new Node((dx, dy), )
        }

        void Process(string[] args)
        {
            var inputs1 = InputIntValues(3);
            int H, W, T;
            H = inputs1[0];
            W = inputs1[1];
            T = inputs1[2];
            var s = new List<List<string>>();
            for(int y = 0; y < H; y++) {
                s[y] = new List<string>();
                string row = Console.ReadLine();
                for(int x = 0; x < W; x++) {
                    s[y][x] = row.Split()[x];
                }
            }
        }

        static List<int> InputIntValues(int length) {
            string rowInput = Console.ReadLine();
            string[] strings = rowInput.Split(' ');
            List<int> returnvalue = new List<int>(length);
            for(int i = 0; i < length; i++) {
                returnvalue[i] = int.Parse(strings[i]);
            }
            return returnvalue;
        }

        static List<List<int>> InputIntMatrix(int X, int Y) {
            var matrix = new List<List<int>>();
            for(int i = 0; i < Y; i++) {
                string row = Console.ReadLine();
                string[] strings = row.Split(' ');
                matrix[i] = new List<int>();
                for (int j = 0; j < X; j++) {
                    matrix[i][j] = int.Parse(strings[j]);
                }
            }
            return matrix;
        }

        static List<List<string>> InputStringMatrix(int X, int Y) {
            var matrix = new List<List<string>>();
            for (int i = 0; i < Y; i++) {
                string row = Console.ReadLine();
                string[] strings = row.Split(' ');
                matrix[i] = new List<string>();
                for (int j = 0; j < X; j++) {
                    matrix[i][j] = strings[j];
                }
            }
            return matrix;
        }
    }*/
}

namespace ProCon {
    class Program {
        static void Main(string[] args) {
            int n = int.Parse(Console.ReadLine());
            if (n >= 189) Console.WriteLine(4);
            else if (n >= 165) Console.WriteLine(3);
            else if (n >= 135) Console.WriteLine(2);
            else if (n >= 105) Console.WriteLine(1);
            else Console.WriteLine(0);
        }

        static List<int> InputIntValues(int length) {
            string rowInput = Console.ReadLine();
            string[] strings = rowInput.Split(' ');
            List<int> returnvalue = new List<int>(length);
            for (int i = 0; i < length; i++) {
                returnvalue.Add(int.Parse(strings[i]));
            }
            return returnvalue;
        }

        static List<List<int>> InputIntMatrix(int X, int Y) {
            var matrix = new List<List<int>>();
            for (int i = 0; i < Y; i++) {
                string row = Console.ReadLine();
                string[] strings = row.Split(' ');
                matrix.Add(new List<int>());
                for (int j = 0; j < X; j++) {
                    matrix[i].Add(int.Parse(strings[j]));
                }
            }
            return matrix;
        }

        static List<List<string>> InputStringMatrix(int X, int Y) {
            var matrix = new List<List<string>>();
            for (int i = 0; i < Y; i++) {
                string row = Console.ReadLine();
                string[] strings = row.Split(' ');
                matrix.Add(new List<string>());
                for (int j = 0; j < X; j++) {
                    matrix[i].Add(strings[j]);
                }
            }
            return matrix;
        }
    }
}