import java.util.*;

public class Task080126 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        Comparator<Integer> comparator = (a, b) -> b - a;
        int index = Collections.binarySearch(list, 1, comparator);
        System.out.println(index);
    }
}

public class ConstantTimeExample {
    private int[] array;
    
    public int getElement(int index) {
        // Всегда выполняется за фиксированное время
        return array[index];
    }
    
    public boolean isEven(int number) {
        // Математическая операция также O(1)
        return number % 2 == 0;
    }
}

public class BinarySearch {
    public static int search(int[] sortedArray, int target) {
        int left = 0;
        int right = sortedArray.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2; // Избегаем переполнения
            
            if (sortedArray[mid] == target) {
                return mid;
            } else if (sortedArray[mid] < target) {
                left = mid + 1; // Отбрасываем левую половину
            } else {
                right = mid - 1; // Отбрасываем правую половину
            }
        }
        return -1; // Элемент не найден
    }
}

public class LinearTimeExample {
    public static int findMax(int[] array) {
        if (array.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }
        
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

public class MergeSort {
    public static void sort(int[] array) {
        if (array.length <= 1) return;
        
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        
        sort(left);
        sort(right);
        
        merge(array, left, right);
    }
    
    private static void merge(int[] result, int[] left, int[] right) {
        int i = 0, j = 0, k = 0;
        
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                result[k++] = left[i++];
            } else {
                result[k++] = right[j++];
            }
        }
        
        while (i < left.length) result[k++] = left[i++];
        while (j < right.length) result[k++] = right[j++];
    }
}

public class BubbleSort {
    public static void sort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    // Обмен элементов
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

public class ExponentialExample {
    // Наивная рекурсивная реализация Фибоначчи: O(2ⁿ)
    public static long fibonacciNaive(int n) {
        if (n <= 1) return n;
        return fibonacciNaive(n - 1) + fibonacciNaive(n - 2);
    }
    
    // Динамическое программирование: O(n)
    public static long fibonacciDP(int n) {
        if (n <= 1) return n;
        
        long[] fib = new long[n + 1];
        fib[0] = 0;
        fib[1] = 1;
        
        for (int i = 2; i <= n; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        
        return fib[n];
    }
}

public class QuickSort {
    public static void sort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }
    
    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // Разделение массива
            int pivotIndex = partition(array, low, high);
            
            // Рекурсивная сортировка частей
            quickSort(array, low, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, high);
        }
    }
    
    private static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // Выбор опорного элемента
        int i = low - 1;
        
        for (int j = low; j < high; j++) {
            if (array[j] <= pivot) {
                i++;
                swap(array, i, j);
            }
        }
        
        swap(array, i + 1, high);
        return i + 1;
    }
    
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

public class OptimizedQuickSort {
    private static final int INSERTION_THRESHOLD = 16;
    
    public static void sort(int[] array) {
        randomizedQuickSort(array, 0, array.length - 1);
    }
    
    private static void randomizedQuickSort(int[] array, int low, int high) {
        // Для маленьких массивов используем сортировку вставками
        if (high - low < INSERTION_THRESHOLD) {
            insertionSort(array, low, high);
            return;
        }
        
        // Рандомизированный выбор опорного элемента
        int randomIndex = low + (int)(Math.random() * (high - low + 1));
        swap(array, randomIndex, high);
        
        int pivotIndex = partition(array, low, high);
        randomizedQuickSort(array, low, pivotIndex - 1);
        randomizedQuickSort(array, pivotIndex + 1, high);
    }
}

public class Task090126 {
    public static void main(String[] args) {
        int n = 10;
        int count = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j += i) {
                count++;
            }
        }
        System.out.println(count);
    }
}