Hello codeforces! I just knew one interesting fact. Codeforces round have more priority, then any other submissions. It is logical, but here is one moment. Submission that already testing also have less priority, and it is strange. I had submissions, that were "testing on 40th test", but now they are in queue again. I thing, that MikeMirzayanov must fix it.

In C++, pragmas are directives provided by the compiler to control various aspects of the compilation process. Pragmas are typically specific to a particular compiler, and their usage might not be standardized across different compilers. Here are some common C++ pragmas and their purposes:

1. pragma once:

• This pragma is used for header file guards. It ensures that the header file is included only once during compilation, helping to prevent multiple inclusions and potential issues with redefinitions.

#pragma once

1. pragma comment(lib, "library_name"):

• This pragma is often used in Microsoft Visual Studio to specify linking with a particular library. It's a way to include a library without explicitly adding it to the project settings.

#pragma comment(lib, "user32.lib")

1. pragma message("message text"):

• This pragma allows you to generate a compiler message. It's often used for informational or debugging purposes. The message specified will be displayed during compilation.

#pragma message("Compiling: This is an informational message.")

1. pragma warning:

• This pragma allows you to control warning messages issued by the compiler. You can enable or disable specific warnings or set their severity level.

#pragma warning(disable: 4996) // Disable warning 4996

1. pragma pack(n):

• This pragma controls the alignment of structure members in memory. It specifies the alignment boundary for structure members.

#pragma pack(1) // Set the alignment to 1 byte

1. pragma GCC optimize:

• This pragma is used in GCC (GNU Compiler Collection) to control optimization options. It allows you to specify optimization levels for specific functions or code sections.

#pragma GCC optimize("O3") // Optimize with level 3

1. pragma omp:

• OpenMP (Open Multi-Processing) directives are often used with this pragma to enable parallel programming in C++. It allows developers to specify parallel regions and control parallel execution.

#pragma omp parallel for
for (int i = 0; i < size; ++i) {
    // Parallelized loop
}

Keep in mind that while pragmas can be powerful tools for controlling compiler behavior, excessive or inappropriate use of pragmas can lead to non-portable code. It's essential to be aware of the compiler-specific nature of pragmas and use them judiciously based on the targeted compiler and platform.

AVX (Advanced Vector Extensions) is an instruction set extension designed for SIMD (Single Instruction, Multiple Data) operations. It's an extension of Intel's x86 and x86-64 architectures, providing wider vector registers and additional instructions to perform parallel processing on multiple data elements simultaneously.

In C++, you can leverage AVX through intrinsics, which are special functions that map directly to low-level machine instructions. AVX intrinsics allow you to write code that explicitly uses the AVX instructions, taking advantage of SIMD parallelism to accelerate certain computations.

Here's a brief overview of using AVX in C++:

1. Include Header: To use AVX intrinsics, include the appropriate header file. For AVX, you'll need <immintrin.h>.

#include <immintrin.h>

1. Data Types: AVX introduces new data types, such as m256 for 256-bit wide vectors of single-precision floating-point numbers (float). There are corresponding types for double-precision (m256d) and integer data.

2. Intrinsics: Use AVX intrinsics to perform SIMD operations. For example, _mm256_add_ps adds two 256-bit vectors of single-precision floating-point numbers.

__m256 a = _mm256_set_ps(4.0, 3.0, 2.0, 1.0, 8.0, 7.0, 6.0, 5.0);
__m256 b = _mm256_set_ps(8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0);
__m256 result = _mm256_add_ps(a, b);

1. Compiler Flags: Ensure that your compiler is configured to generate code that uses AVX instructions. For GCC, you might use flags like -mavx or -march=native to enable AVX support.

g++ -mavx -o your_program your_source.cpp

1. Caution: Be aware that using intrinsics ties your code to specific hardware architectures. Ensure that your target platform supports AVX before relying heavily on these instructions.

2. Performance Considerations: AVX can significantly boost performance for certain workloads, especially those involving parallelizable operations on large datasets. However, its effectiveness depends on the specific nature of the computations.

Always consider the trade-offs, and profile your code to ensure that the expected performance gains are achieved. Additionally, keep in mind that the use of intrinsics requires careful consideration of data alignment and memory access patterns for optimal performance.

I recently learned about a very cool technique — parallel binary search.

Parallel binary search is a technique used to efficiently search for an element in a sorted array using parallel processing. Instead of performing a traditional binary search sequentially, this approach divides the search space among multiple processors or threads, allowing for concurrent searches.

The basic idea involves each processor or thread maintaining its own subrange of the array and performing a binary search within that subrange. Communication between processors is necessary to ensure a coordinated search, as they may need to adjust their search ranges based on the results obtained by other processors.

Parallel binary search is particularly beneficial when dealing with large datasets, as it can significantly reduce the overall search time by leveraging the parallel processing capabilities of modern computing systems.

Keep in mind that implementing parallel algorithms requires careful synchronization and coordination to ensure correctness and efficiency. It's often used in parallel computing environments to take advantage of multi-core processors or distributed systems.