// ============================================================
// СТАНДАРТНАЯ БИБЛИОТЕКА РУСИ
// ============================================================
// Объединение всех стандартных заголовочных файлов C11
// в единый модуль с русскими синонимами.
//
// Включает:
//   - float.h      — характеристики типов с плавающей точкой
//   - stdalign.h   — макросы для работы с выравниванием типов
//   - stdarg.h     — макросы для работы с переменным числом аргументов
//   - stdatomic.h  — атомарные операции и типы
//   - stdbool.h    — булевый тип данных
//   - stddef.h     — стандартные определения типов и макросов
//   - stdnoreturn.h — спецификатор невозвратных функций
// ============================================================

#ifndef _STDLIB_RU
#define _STDLIB_RU

// ============================================================
// float.h - Характеристики типов с плавающей точкой
// ============================================================

// Общие параметры представления чисел с плавающей точкой
#define DECIMAL_DIG 21
#define FLT_EVAL_METHOD 0
#define FLT_RADIX 2
#define FLT_ROUNDS 1

// Характеристики типа float (одинарная точность, 32 бита)
#define FLT_DIG 6
#define FLT_EPSILON 0x1p-23
#define FLT_MANT_DIG 24
#define FLT_MAX 0x1.fffffep+127
#define FLT_MAX_10_EXP 38
#define FLT_MAX_EXP 128
#define FLT_MIN 0x1p-126
#define FLT_MIN_10_EXP -37
#define FLT_MIN_EXP -125
#define FLT_TRUE_MIN 0x1p-149

// Характеристики типа double (двойная точность, 64 бита)
#define DBL_DIG 15
#define DBL_EPSILON 0x1p-52
#define DBL_MANT_DIG 53
#define DBL_MAX 0x1.fffffffffffffp+1023
#define DBL_MAX_10_EXP 308
#define DBL_MAX_EXP 1024
#define DBL_MIN 0x1p-1022
#define DBL_MIN_10_EXP -307
#define DBL_MIN_EXP -1021
#define DBL_TRUE_MIN 0x0.0000000000001p-1022

// Характеристики типа long double (расширенная точность, 80/128 бит)
#define LDBL_DIG 15
#define LDBL_EPSILON 0x1p-52
#define LDBL_MANT_DIG 53
#define LDBL_MAX 0x1.fffffffffffffp+1023
#define LDBL_MAX_10_EXP 308
#define LDBL_MAX_EXP 1024
#define LDBL_MIN 0x1p-1022
#define LDBL_MIN_10_EXP -307
#define LDBL_MIN_EXP -1021
#define LDBL_TRUE_MIN 0x0.0000000000001p-1022

// Русские синонимы для float.h
#define ДЕСЯТИЧНЫХ_ЦИФР DECIMAL_DIG
#define МЕТОД_ОЦЕНКИ FLT_EVAL_METHOD
#define ОСНОВАНИЕ FLT_RADIX
#define РЕЖИМ_ОКРУГЛЕНИЯ FLT_ROUNDS

#define ОДИНАР_ЦИФР FLT_DIG
#define ОДИНАР_ЭПСИЛОН FLT_EPSILON
#define ОДИНАР_МАНТИССА FLT_MANT_DIG
#define ОДИНАР_МАКС FLT_MAX
#define ОДИНАР_МАКС_10_СТЕП FLT_MAX_10_EXP
#define ОДИНАР_МАКС_СТЕП FLT_MAX_EXP
#define ОДИНАР_МИН FLT_MIN
#define ОДИНАР_МИН_10_СТЕП FLT_MIN_10_EXP
#define ОДИНАР_МИН_СТЕП FLT_MIN_EXP
#define ОДИНАР_МИН_ДЕНОРМ FLT_TRUE_MIN

#define ДВОЙН_ЦИФР DBL_DIG
#define ДВОЙН_ЭПСИЛОН DBL_EPSILON
#define ДВОЙН_МАНТИССА DBL_MANT_DIG
#define ДВОЙН_МАКС DBL_MAX
#define ДВОЙН_МАКС_10_СТЕП DBL_MAX_10_EXP
#define ДВОЙН_МАКС_СТЕП DBL_MAX_EXP
#define ДВОЙН_МИН DBL_MIN
#define ДВОЙН_МИН_10_СТЕП DBL_MIN_10_EXP
#define ДВОЙН_МИН_СТЕП DBL_MIN_EXP
#define ДВОЙН_МИН_ДЕНОРМ DBL_TRUE_MIN

#define ДЛИН_ЦИФР LDBL_DIG
#define ДЛИН_ЭПСИЛОН LDBL_EPSILON
#define ДЛИН_МАНТИССА LDBL_MANT_DIG
#define ДЛИН_МАКС LDBL_MAX
#define ДЛИН_МАКС_10_СТЕП LDBL_MAX_10_EXP
#define ДЛИН_МАКС_СТЕП LDBL_MAX_EXP
#define ДЛИН_МИН LDBL_MIN
#define ДЛИН_МИН_10_СТЕП LDBL_MIN_10_EXP
#define ДЛИН_МИН_СТЕП LDBL_MIN_EXP
#define ДЛИН_МИН_ДЕНОРМ LDBL_TRUE_MIN

// ============================================================
// stdalign.h - Макросы для работы с выравниванием типов
// ============================================================

#define alignas _Alignas
#define alignof _Alignof
#define __alignas_is_defined 1
#define __alignof_is_defined 1

// Русские синонимы для stdalign.h
#define выравн _Alignas
#define выравн_размер _Alignof

// ============================================================
// stdarg.h - Макросы для работы с переменным числом аргументов
// ============================================================

typedef struct {
  unsigned int gp_offset;
  unsigned int fp_offset;
  void *overflow_arg_area;
  void *reg_save_area;
} __va_state;

typedef __va_state va_list[1];

#define va_start(ap, last) \
  do { *(ap) = *(__va_state *)__va_area__; } while (0)

#define va_end(ap)

static void *__va_read_from_stack(__va_state *ap, int sz, int align) {
  void *p = ap->overflow_arg_area;
  if (align > 8)
    p = (p + 15) / 16 * 16;
  ap->overflow_arg_area = ((unsigned long)p + sz + 7) / 8 * 8;
  return p;
}

static void *__va_read_from_gp(__va_state *ap, int sz, int align) {
  if (ap->gp_offset >= 48)
    return __va_read_from_stack(ap, sz, align);

  void *r = ap->reg_save_area + ap->gp_offset;
  ap->gp_offset += 8;
  return r;
}

static void *__va_read_from_fp(__va_state *ap, int sz, int align) {
  if (ap->fp_offset >= 112)
    return __va_read_from_stack(ap, sz, align);

  void *r = ap->reg_save_area + ap->fp_offset;
  ap->fp_offset += 8;
  return r;
}

#define va_arg(ap, ty)                                                  \
  ({                                                                    \
    int klass = __builtin_reg_class(ty);                                \
    *(ty *)(klass == 0 ? __va_read_from_gp(ap, sizeof(ty), _Alignof(ty)) :    \
            klass == 1 ? __va_read_from_fp(ap, sizeof(ty), _Alignof(ty)) :    \
            __va_read_from_stack(ap, sizeof(ty), _Alignof(ty)));              \
  })

#define va_copy(dest, src) ((dest)[0] = (src)[0])

#define __GNUC_VA_LIST 1
typedef va_list __gnuc_va_list;

// Русские синонимы для stdarg.h
#define аргументы va_list
#define арг_начало va_start
#define арг_конец va_end
#define арг_взять va_arg
#define арг_копия va_copy

// ============================================================
// stdatomic.h - Атомарные операции и типы
// ============================================================

#define ATOMIC_BOOL_LOCK_FREE 1
#define ATOMIC_CHAR_LOCK_FREE 1
#define ATOMIC_CHAR16_T_LOCK_FREE 1
#define ATOMIC_CHAR32_T_LOCK_FREE 1
#define ATOMIC_WCHAR_T_LOCK_FREE 1
#define ATOMIC_SHORT_LOCK_FREE 1
#define ATOMIC_INT_LOCK_FREE 1
#define ATOMIC_LONG_LOCK_FREE 1
#define ATOMIC_LLONG_LOCK_FREE 1
#define ATOMIC_POINTER_LOCK_FREE 1

typedef enum {
  memory_order_relaxed,
  memory_order_consume,
  memory_order_acquire,
  memory_order_release,
  memory_order_acq_rel,
  memory_order_seq_cst,
} memory_order;

#define порядок_ослабленный memory_order_relaxed
#define порядок_потребление memory_order_consume
#define порядок_приобретение memory_order_acquire
#define порядок_освобождение memory_order_release
#define порядок_приобретение_освобождение memory_order_acq_rel
#define порядок_последовательный memory_order_seq_cst

#define ATOMIC_FLAG_INIT(x) (x)
#define atomic_init(addr, val) (*(addr) = (val))
#define kill_dependency(x) (x)
#define atomic_thread_fence(order)
#define atomic_signal_fence(order)
#define atomic_is_lock_free(x) 1

#define atomic_load(addr) (*(addr))
#define atomic_store(addr, val) (*(addr) = (val))
#define atomic_load_explicit(addr, order) (*(addr))
#define atomic_store_explicit(addr, val, order) (*(addr) = (val))

#define атом_загрузить(addr) atomic_load(addr)
#define атом_сохранить(addr, val) atomic_store(addr, val)
#define атом_загрузить_явно(addr, order) atomic_load_explicit(addr, order)
#define атом_сохранить_явно(addr, val, order) atomic_store_explicit(addr, val, order)

#define atomic_fetch_add(obj, val) (*(obj) += (val))
#define atomic_fetch_sub(obj, val) (*(obj) -= (val))
#define atomic_fetch_or(obj, val) (*(obj) |= (val))
#define atomic_fetch_xor(obj, val) (*(obj) ^= (val))
#define atomic_fetch_and(obj, val) (*(obj) &= (val))

#define atomic_fetch_add_explicit(obj, val, order) (*(obj) += (val))
#define atomic_fetch_sub_explicit(obj, val, order) (*(obj) -= (val))
#define atomic_fetch_or_explicit(obj, val, order) (*(obj) |= (val))
#define atomic_fetch_xor_explicit(obj, val, order) (*(obj) ^= (val))
#define atomic_fetch_and_explicit(obj, val, order) (*(obj) &= (val))

#define атом_прибавить(obj, val) atomic_fetch_add(obj, val)
#define атом_вычесть(obj, val) atomic_fetch_sub(obj, val)
#define атом_или(obj, val) atomic_fetch_or(obj, val)
#define атом_исключ_или(obj, val) atomic_fetch_xor(obj, val)
#define атом_и(obj, val) atomic_fetch_and(obj, val)

#define атом_прибавить_явно(obj, val, order) atomic_fetch_add_explicit(obj, val, order)
#define атом_вычесть_явно(obj, val, order) atomic_fetch_sub_explicit(obj, val, order)
#define атом_или_явно(obj, val, order) atomic_fetch_or_explicit(obj, val, order)
#define атом_исключ_или_явно(obj, val, order) atomic_fetch_xor_explicit(obj, val, order)
#define атом_и_явно(obj, val, order) atomic_fetch_and_explicit(obj, val, order)

#define atomic_compare_exchange_weak(p, old, new) \
  __builtin_compare_and_swap((p), (old), (new))

#define atomic_compare_exchange_strong(p, old, new) \
  __builtin_compare_and_swap((p), (old), (new))

#define atomic_exchange(obj, val) __builtin_atomic_exchange((obj), (val))
#define atomic_exchange_explicit(obj, val, order) __builtin_atomic_exchange((obj), (val))

#define атом_сравнить_обменять_слабо(p, old, new) atomic_compare_exchange_weak(p, old, new)
#define атом_сравнить_обменять(p, old, new) atomic_compare_exchange_strong(p, old, new)
#define атом_обменять(obj, val) atomic_exchange(obj, val)
#define атом_обменять_явно(obj, val, order) atomic_exchange_explicit(obj, val, order)

#define atomic_flag_test_and_set(obj) atomic_exchange((obj), 1)
#define atomic_flag_test_and_set_explicit(obj, order) atomic_exchange((obj), 1)
#define atomic_flag_clear(obj) (*(obj) = 0)
#define atomic_flag_clear_explicit(obj, order) (*(obj) = 0)

#define атом_флаг_проверить_установить(obj) atomic_flag_test_and_set(obj)
#define атом_флаг_проверить_установить_явно(obj, order) atomic_flag_test_and_set_explicit(obj, order)
#define атом_флаг_очистить(obj) atomic_flag_clear(obj)
#define атом_флаг_очистить_явно(obj, order) atomic_flag_clear_explicit(obj, order)

typedef _Atomic _Bool atomic_flag;
typedef _Atomic _Bool atomic_bool;
typedef _Atomic char atomic_char;
typedef _Atomic signed char atomic_schar;
typedef _Atomic unsigned char atomic_uchar;
typedef _Atomic short atomic_short;
typedef _Atomic unsigned short atomic_ushort;
typedef _Atomic int atomic_int;
typedef _Atomic unsigned int atomic_uint;
typedef _Atomic long atomic_long;
typedef _Atomic unsigned long atomic_ulong;
typedef _Atomic long long atomic_llong;
typedef _Atomic unsigned long long atomic_ullong;
typedef _Atomic unsigned short atomic_char16_t;
typedef _Atomic unsigned atomic_char32_t;
typedef _Atomic unsigned atomic_wchar_t;
typedef _Atomic signed char atomic_int_least8_t;
typedef _Atomic unsigned char atomic_uint_least8_t;
typedef _Atomic short atomic_int_least16_t;
typedef _Atomic unsigned short atomic_uint_least16_t;
typedef _Atomic int atomic_int_least32_t;
typedef _Atomic unsigned int atomic_uint_least32_t;
typedef _Atomic long atomic_int_least64_t;
typedef _Atomic unsigned long atomic_uint_least64_t;
typedef _Atomic signed char atomic_int_fast8_t;
typedef _Atomic unsigned char atomic_uint_fast8_t;
typedef _Atomic short atomic_int_fast16_t;
typedef _Atomic unsigned short atomic_uint_fast16_t;
typedef _Atomic int atomic_int_fast32_t;
typedef _Atomic unsigned int atomic_uint_fast32_t;
typedef _Atomic long atomic_int_fast64_t;
typedef _Atomic unsigned long atomic_uint_fast64_t;
typedef _Atomic long atomic_intptr_t;
typedef _Atomic unsigned long atomic_uintptr_t;
typedef _Atomic unsigned long atomic_size_t;
typedef _Atomic long atomic_ptrdiff_t;
typedef _Atomic long atomic_intmax_t;
typedef _Atomic unsigned long atomic_uintmax_t;

// ============================================================
// stdbool.h - Булевый тип данных
// ============================================================

#define bool _Bool
#define true 1
#define false 0

#define бул _Bool
#define истина 1
#define ложь 0

#define __bool_true_false_are_defined 1

// ============================================================
// stddef.h - Стандартные определения типов и макросов
// ============================================================

#define NULL ((void *)0)

typedef unsigned long size_t;
typedef long ptrdiff_t;
typedef unsigned int wchar_t;
typedef long max_align_t;

#define offsetof(type, member) ((size_t)&(((type *)0)->member))

#define НУЛЬ NULL
typedef size_t размер_t;
typedef ptrdiff_t разность_t;
typedef wchar_t шсимвол_t;
typedef max_align_t макс_выравн_t;
#define смещение(type, member) offsetof(type, member)

// ============================================================
// stdnoreturn.h - Спецификатор невозвратных функций
// ============================================================

#define noreturn _Noreturn
#define безвозврат _Noreturn

#endif // _STDLIB_RU