feat: написаны функции сравнения времени выполнения

Вроде там еще надо будет что-то сравнить по быстродействию, это добавлю в будущих коммитах

01-asm-basics/time.asm

@@ -0,0 +1,67 @@
+global main
+
+extern printf
+
+%define CLOCK_REALTIME 0
+
+; struct timespec { time_t tv_sec; long tv_nsec; }
+struc timespec
+  .tv_sec: resq 1
+  .tv_nsec: resq 1
+endstruc
+
+section .note.GNU-stack ; чтобы не жаловался линкер
+
+section .bss
+
+start: ; uses timespec model
+  times 2 resq 1
+
+finish:
+  times 2 resq 1
+
+section .data
+
+  fstring db "Operations took %ul seconds and %ul milliseconds", 10, 0
+  flen equ $-fstring
+
+section .text
+
+main: ; лично в моей системе time_t представляет из себя long int
+  mov rax, 228 ; Системный вызов получения времени
+  mov rdi, CLOCK_REALTIME
+  mov rsi, start
+  syscall
+
+  ; insert your code here
+  mov rcx, 20000
+
+  looper:
+  mov rax, start
+  loop looper
+
+  mov rax, 228
+  mov rdi, CLOCK_REALTIME
+  mov rsi, finish
+  syscall
+
+  ; считаем время для секунда и миллисекунд
+  ; секунды
+  mov rsi, [finish + timespec.tv_sec]
+  sub rsi, [start + timespec.tv_sec]
+
+  ; миллисекунды
+  mov rdx, [finish + timespec.tv_nsec]
+  sub rdx, [start + timespec.tv_nsec]
+
+  mov rdi, fstring
+  mov rax, 0
+  sub rsp, 8
+  call printf
+  add rsp, 8
+
+exit:
+  mov rax, 60
+  mov rdi, 0
+  syscall
+

03-asm-bios/README.md

@@ -2,13 +2,3 @@
 
 ## Ассемблер и функции BIOS
 
-В этой работе намного проще посмотреть непосредственно решения и почитать комментарии к коду, чем читать теоретическое приложение к работе. Если вам все же что-то не понятно - кидайте в issues
-
-Впрочем зная, что основная масса народу не будет делать эту лабу так, как сделал ее я, сюда вряд ли кто-то заглянет)
-
-### Касаемо Makefile
-
-Для того чтобы не писать много команд для однотипной и монотонной сборки проекта, был написан простой Makefile. Однако работает он следующим образом: он принимает название цели сборки и ищет файл с именем цели и расширением .asm. Если не находит - не собирает цель.
-
-Важно заметить, что он не умеет линковать другие файлы в ассемблер, потому что написан был не для этого. Он просто берет голый файл на NASM (обязательно) и выдает 64-битный ELF из этого единственного файла. Если вам необходимо что-то прилинковать к ассемблеру, то увы, придется собирать проект вручную или менять этот makefile
-

03-asm-bios/task2.asm

@@ -1,81 +0,0 @@
-global _start
-
-%define STDIN   0
-%define STDOUT  1
-%define STDERR  2
-
-section .data
-  src db 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
-  src_size equ $-src
-
-  ; резервируем 1 килобайт для буффера ввода и вывода
-  ; также в отдельной переменной сохраняем размер этого буфера
-  print_buf: times 1024 db 0
-  buf_size equ $-print_buf
-
-section .text
-
-%macro DIGIT_TO_ASCII 1 ; макрос, принимающий один регистр
-  add %1, '0'
-%endmacro
-
-%macro PUSH_M 1-* ; push many; пушит в порядке следования
-  %rep %0
-  push %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro POP_M 1-* ; pop many. читает в порядке следования
-  %rep %0
-  pop %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro RPOP_M 1-* ; pop many. читает в обратном порядке
-  %rotate -1
-  %rep %0
-  pop %1
-  %rotate -1
-  %endrep
-%endmacro
-
-; Передачу аргументов будем делать при помощи ABI - стандартная практика для linux
-; Аргументы передаются в следующем порядке: rdi, rsi, rdx, rcx, r8, r9. Все, что не влезло, пушится в стек
-; У передачи через стек тоже есть особенности, но их мы пока касаться не будем
-
-print_from_buf: ; word -> void
-
-  PUSH_M rax, rsi, rdx, rdi ; сохраним регистры, которые точно попортим
-  mov rdx, rdi ; сколько выводить, в rdi содержится единственный аргумент
-  mov rsi, print_buf ; откуда выводить. Адрес буфера
-  mov rdi, STDOUT; куда выводить. Дескриптор файла. В нашем случае стандартного вывода
-  mov rax, 1
-  syscall
-
-  RPOP_M rax, rsi, rdx, rdi ; вернем значения регистров
-  ret
-
-_start:
-  mov rcx, src_size
-  mov rsi, src
-  mov rdi, print_buf
-  
-  xor rax, rax ; обнуляем регистр
-  .transfer: ; в цикле передаем данные, попутно конвертируя их в ascii
-  lodsb
-  DIGIT_TO_ASCII rax
-  stosb 
-  loop .transfer
-
-  mov [rdi + 1], BYTE `\n` ; Чтобы система не ругалась на отсутствие переноса
-
-  mov rdi, src_size
-  call print_from_buf
-
-exit:
-  mov rax, 60
-  mov rdi, 0
-  syscall
-

03-asm-bios/task4.asm

@@ -1,219 +0,0 @@
-global _start
-
-%define STDIN   0
-%define STDOUT  1
-%define STDERR  2
-
-section .data
-
-  ; резервируем 1 килобайт для буффера ввода и вывода
-  ; также в отдельной переменной сохраняем размер этого буфера
-  print_buf: times 1024 db 0
-  buf_size equ $-print_buf
-
-  input_buf: times 1024 db 0 ; буфер, в который будут читаться символы со стандартного ввода
-  input_size equ $-input_buf
-
-  array: times 512 dq 0 ; молимся, чтобы никому не пришло в голову писать так много
-  arr_size equ $-array
-
-  ; Для poll
-  %define POLLIN 0x001 ; Есть ли что почитать с буфера ввода. Понадобится для продолжения ввода
-  input_pollfd: dd STDIN
-                dw POLLIN
-  revents:      dw 0 ; возвращаемые события
-
-section .text
-
-%macro DIGIT_TO_ASCII 1 ; макрос, принимающий один аргумент (регистр или память)
-  add %1, '0'
-%endmacro
-
-%macro ASCII_TO_DIGIT 1 ; макрос, принимающий один аргумент (регистр или память)
-  sub %1, '0'
-%endmacro
-
-%macro PUSH_M 1-* ; push many; пушит в порядке следования
-  %rep %0
-  push %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro POP_M 1-* ; pop many. читает в порядке следования
-  %rep %0
-  pop %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro RPOP_M 1-* ; pop many. читает в обратном порядке
-  %rotate -1
-  %rep %0
-  pop %1
-  %rotate -1
-  %endrep
-%endmacro
-
-%macro PUSHR8 1; закинуть восьмибитный регистр в стек
-  dec rsp
-  mov [rsp], %1
-%endmacro
-
-; Передачу аргументов будем делать при помощи ABI - стандартная практика для linux
-; Аргументы передаются в следующем порядке: rdi, rsi, rdx, rcx, r8, r9. Все, что не влезло, пушится в стек
-; У передачи через стек тоже есть особенности, но их мы пока касаться не будем
-
-clean_print_buf: ; none -> void
-  PUSH_M rax, rcx, rdi
-  mov rcx, buf_size
-  mov rdi, print_buf
-  xor rax, rax ; будем заносить нули во всю память
-  rep stosb
-  RPOP_M rax, rcx, rdi
-  ret
-
-print_from_buf: ; qword -> void; пытается вывести данные из буфера. аргумент не может быть больше 1024
-  PUSH_M rax, rsi, rdx, rdi ; сохраним регистры, которые точно попортим
-  mov rdx, rdi ; сколько выводить, в rdi содержится единственный аргумент
-  mov rsi, print_buf ; откуда выводить. Адрес буфера
-  mov rdi, STDOUT; куда выводить. Дескриптор файла. В нашем случае стандартного вывода
-  mov rax, 1
-  push rcx
-  syscall
-  pop rcx
-  RPOP_M rax, rsi, rdx, rdi ; вернем значения регистров
-  ret
-
-read_to_buf: ; none -> void. Пытается заполнить буфер из стандартного ввода
-  PUSH_M rdi, rsi, rdx
-  mov rdi, STDIN ; откуда читать (дескриптор файла)
-  mov rsi, input_buf ; куда читать
-  mov rdx, input_size ; Сколько пытаемся читать
-  mov rax, 0 ; системный вызов чтения
-  syscall
-  RPOP_M rdi, rsi, rdx ; rax содержит количество прочитанных байт, а это важно
-  ret
-
-poll_stdin:
-  PUSH_M rdi, rsi, rdx
-  mov rsi, 1 ; следим только за одним потоком
-  mov rax, 7 ; poll syscall
-  mov rdi, input_pollfd
-  mov rsi, 1 ; одна структура данных (изначально просто вызов принимает кучу таких)
-  mov rdx, 0 ; не ждать
-  syscall
-  RPOP_M rdi, rsi, rdx
-  ret
-
-print_number: ; qword (rdi) -> void
-  ; наша задача - сформировать массив символов.
-  ; Ну а раз мы не знаем точно сколько их будет, формировать его будем прямо в стеке. нам повезло, что он растет вниз
-  ; Нам очень повезло, что он растет вниз
-  ; создадим 2 локальные переменные - одну для размера массива, другую для делителя
-  push rbp
-  PUSH_M rdx, rdi, rsi ; сохранять регистры обязательно надо до того, как писать в стек символы
-  ; создаем базу для адресации. Тогда первая будет на rbp - 8 - делитель, а вторая на rbp - 16 - количество
-  mov rbp, rsp
-  ; [WARNING] тут надо будет сохранить регистры
-  push rsp ; сохраню, потому что после всей вакханалии я концов не сыщу
-  sub rsp, 16 ; выделяем место под 3 переменные
-  mov qword [rbp - 16], 10 ; пусть и жирно, но операнд обязан быть 64 разрядным для корректного деления
-  mov qword [rbp - 24], 0 ; счетчик
-  mov rax, rdi
-  push byte 0 ; при выводе он ориентируется на это как на конец строки
-  .division_loop:
-  xor rdx, rdx ; обнулим найденый остаток. (он просто еще и при делении принимает участие)
-  div qword [rbp - 16]
-  DIGIT_TO_ASCII dl
-  PUSHR8 dl ; поскольку в процессор не завезли возможность закинуть в стек 8 битный регистр, я им немного помог макросами
-  inc qword [rbp - 24] ; увеличиваем счетчик на единицу
-  test rax, rax ; делает and поразрядное с самим собой. Меня интересует, лежит ли в rax ноль
-  jnz .division_loop ; если в rax не ноль, то продолжаем цикл
-  ; выводим число
-  mov rax, 1
-  mov rdi, STDOUT
-  mov rsi, rsp
-  mov rdx, [rbp-24] ; уже не надо очищать, потому что в конце я просто восстановлю как было
-  push rcx
-  syscall
-  pop rcx
-
-  mov rsp, [rbp - 8]
-  RPOP_M rdx, rdi, rsi
-  pop rbp
-  ret
-
-_start:
-  mov rbp, rsp
-  ; Создадим 2 локальные переменные для аккумулятора размером 8 байт и для математических нужд 8 байт.
-  ; аккумулятор будет по адресу rbp - 8, а временная по rbp - 16
-  sub rsp, 16 
-  ; потом я не удержался и завел еще одну переменную - сколько мы успели написать в массив
-  sub rsp, 2 ; массив все равно размером всего 512, делать переменную больше нет смысла. rbp - 18
-
-  mov rsi, input_buf
-  mov rdi, array
-  .read_loop:
-  call read_to_buf ; системный вызов read вернет количество прочитаных байтов
-  mov rcx, rax ; сколько байтов прочиталось, столько и обработаем
-  ; обработаем информацию
-  xor rax, rax ; обнулим на всякий пожарный
-  jmp .read_byte
-
-  .separator_occured:
-  dec rcx
-  mov rax, [rbp - 8]
-  stosq
-  xor rax, rax
-  inc word [rbp - 18]
-  mov qword [rbp - 8], 0
-  test rcx, rcx
-  jz .check_buf
-  
-  .read_byte: ; цикл чтения
-  lodsb
-  ; проверим, цифра ли это. Если нет, то записываем в память то, что хранилось в локальной переменной
-  cmp al, '0'
-  jl .separator_occured
-  cmp al, '9'
-  jg .separator_occured
-
-  ASCII_TO_DIGIT al ; Если цифра, то конвертируем ее из ascii
-  ; Поскольку умножение и деление можно сделать только через регистр, придется извратиться
-  PUSH_M rax, rdx
-  mov rax, [rbp - 8]
-  mov qword [rbp - 16], 10
-  mul qword [rbp - 16]
-  mov [rbp - 8], rax
-  RPOP_M rax, rdx
-  add [rbp - 8], rax ; результат деления запишем в локальную переменную
-  loop .read_byte ; читаем буфер ввода до конца
-
-  .check_buf:
-  call poll_stdin
-  test dword [revents], POLLIN
-  jnz .read_loop
-
-  ; Теперь выведем прочитанный массив на экран
-  xor rcx, rcx
-  mov cx, [rbp - 18]
-  mov rsi, array
-  call clean_print_buf
-  .output_loop:
-  lodsq
-  mov rdi, rax
-  call print_number
-  mov byte [print_buf], ' '
-  mov rdi, 1
-  call print_from_buf ;  печатаем ровно 1 пробел
-  loop .output_loop
-  mov byte [print_buf], `\n`
-  mov rdi, 1
-  call print_from_buf
-
-exit:
-  mov rax, 60
-  mov rdi, 0
-  syscall
-

04-addr-methods/Makefile

@@ -0,0 +1,24 @@
+ASM = nasm
+CXX = gcc
+CXX_FLAGS = -Og -static
+ASM_FLAGS = -felf64 -g
+LINK = ld
+
+task3: task3_c.o task3.o
+	$(CXX) -Og $^ -o $@ -g
+
+task3_c.o: task3.c
+	$(CXX) -Og -c $^ -o $@ -g
+
+task2: task2.o
+	$(CXX) $(CXX_FLAGS) $^ -o $@
+
+%: %.o
+	$(LINK) -o $@ $^
+
+%.o: %.asm
+	$(ASM) $(ASM_FLAGS) $^ -o $@
+
+clean:
+	rm -f *.o
+	rm -f $(subst .asm, $(empty), $(wildcard *.asm))

04-addr-methods/task1.asm

@@ -0,0 +1,33 @@
+ global _start
+
+ section .data
+
+  %macro FILL_ASC 1
+  %assign NUM 0
+  %rep %1
+  db NUM
+  %assign NUM NUM + 1
+  %endrep
+  %endmacro
+
+  example: FILL_ASC 256
+
+ section .text
+
+ _start:
+  ; В качестве базы возьму inc
+  ; регистровая
+  inc ecx
+  mov rax, example
+  ; косвенно-регистровая
+  inc byte [rax]
+  ; "Индексно-базовая", хотя у меня почти все может быть базой
+  inc byte [rax + rbx]
+  ; "Индексно-базовая" со смещением
+  inc byte [rax + rbx + 122]
+
+  ; Ну в целом... все
+  mov rax, 60
+  mov rdi, 0
+  syscall
+  

04-addr-methods/task2.asm

@@ -0,0 +1,139 @@
+global main
+
+extern printf
+
+struc timespec ; структура, в которой линукс хранит время. Тут нужна для удобства в будущем
+  .tv_sec: resq 1
+  .tv_nsec: resq 1
+endstruc
+
+%include "timer.inc"
+
+section .note.GNU-stack
+
+section .data
+  example: times 128 db 127
+
+section .bss
+  ; uses timespec model 
+  start:      resq 2
+  finish:     resq 2
+  deltatime:  resq 2
+
+section .text
+
+%macro PUSH_M 1-*
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-*
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+%define CLOCK_REALTIME 0
+%macro TIME_1_000_000 0-1+ ; принимает команду, которую будет пытаться обмерить по времени
+  PUSH_M rax, rdi, rsi, rcx
+  mov rax, 228 ; Время начала
+  mov rdi, CLOCK_REALTIME
+  mov rsi, start
+  syscall
+  RPOP_M rax, rdi, rsi, rcx
+
+  mov rcx, 10000000000; выполняем миллион раз
+  %%loop:
+  %1
+  loop %%loop
+
+  PUSH_M rax, rdi, rsi, rcx
+  mov rax, 228 ; Время конца
+  mov rdi, CLOCK_REALTIME
+  mov rsi, finish
+  syscall
+  RPOP_M rax, rdi, rsi, rcx
+  
+  ; считаем секунды
+  push rax ; можно было бы оптимизировать, но мне лень макросы переписывать
+  mov rax, [finish + timespec.tv_sec]
+  sub rax, [start + timespec.tv_sec]
+  mov [deltatime + timespec.tv_sec], rax
+
+  ; считаем наносекунды
+  mov rax, [finish + timespec.tv_nsec]
+  sub rax, [start + timespec.tv_nsec]
+  jns %%save_result
+  dec qword [deltatime + timespec.tv_sec] ; занимаем миллиард наносекунд
+  add rax, 1000000000 ; прибавляем занятый разряд
+  %%save_result:
+  mov [deltatime + timespec.tv_nsec], rax
+  pop rax
+%endmacro
+
+%macro PRINT_DELTATIME 1
+  ;sub rsp, 8
+  mov rdi, str_template
+  mov rsi, %1
+  mov rdx, [deltatime + timespec.tv_sec]
+  mov rcx, [deltatime + timespec.tv_nsec]
+  call printf
+  ;add rsp, 8
+%endmacro
+
+main:
+  push rbp
+  mov rbp, rsp
+  sub rsp, 16
+  xor rax, rax ; поскольку приходим сюда из компилятора, лучше обнулить
+  TIME_1_000_000 
+  PRINT_DELTATIME nop_command
+
+  TIME_1_000_000 inc rax
+  PRINT_DELTATIME reg_command
+
+  mov rax, example
+  TIME_1_000_000 inc byte [rax]
+  PRINT_DELTATIME rel_reg
+
+  mov rax, example
+  xor rbx, rbx
+  TIME_1_000_000 inc byte [rax + rbx]
+  PRINT_DELTATIME ind_base
+
+  mov rax, example
+  xor rbx, rbx
+  TIME_1_000_000 inc byte [rax + rbx + 122]
+  PRINT_DELTATIME ind_base_disp
+
+  ; Под конец давайте посчитаем тактовую частоту на примере той же самой команды
+  rdtsc
+  mov [rbp - 4], edx
+  mov [rbp - 8], eax
+  mov rcx, 10000000000
+  mov rax, example
+  xor rbx, rbx
+  .loop:
+  inc byte [rax + rbx + 122]
+  loop .loop
+  rdtsc
+  sub eax, [rbp - 8]
+  sbb edx, [rbp - 4]
+  mov [rbp - 8], eax
+  mov [rbp - 4], edx
+  
+  mov [rbp - 16], rsp
+  and rsp, -16
+  mov rdi, tick_count
+  mov rsi, [rbp - 8]
+  call printf
+
+  mov rsp, rbp
+  pop rbp
+  xor rax, rax ; сообщаем gcc, что все закончилось успешно
+  ret
+

04-addr-methods/task3.asm

@@ -0,0 +1,96 @@
+global fill_arr1
+global fill_arr2
+
+section .note.GNU-stack
+
+section .text
+
+%macro PUSH_M 1-*
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-*
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+fill_arr1:
+  push rbp
+  mov rbp, rsp
+  PUSH_M rdi, rsi, rdx
+  ; Вычисляем сколько числе в строке
+  mov rax, [rbp - 16]
+  xor rdx, rdx
+  div qword [rbp - 24]
+  push rax ; сохраняем в локальные переменные. rbp - 32
+  ; Вычисляем сколько проходов цикла необходимо
+  mov rax, [rbp - 24]
+  xor rdx, rdx
+  mov rcx, 2
+  div rcx
+  push rax ; rbp-40
+
+  ; Надеюсь rdi не успел поменяться
+  ; заполняем память
+  push rbx
+  mov rbx, [rbp - 32]
+  mov rcx, [rbp - 40]
+  mov rax, 777 ; специально такое число, чтобы выделялось
+  .next_row:
+  push rcx
+  mov rcx, [rbp - 32]
+  rep stosd
+  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
+  pop rcx
+  loop .next_row
+  pop rbx
+
+  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
+  RPOP_M rdi, rsi, rdx
+  pop rbp
+  ret
+
+fill_arr2:
+  push rbp
+  mov rbp, rsp
+  PUSH_M rdi, rsi, rdx
+  ; Вычисляем сколько числе в строке
+  mov rax, [rbp - 16]
+  xor rdx, rdx
+  div qword [rbp - 24]
+  push rax ; сохраняем в локальные переменные. rbp - 32
+  ; Вычисляем сколько проходов цикла необходимо
+  mov rax, [rbp - 24]
+  xor rdx, rdx
+  mov rcx, 2
+  div rcx
+  push rax ; rbp-40
+
+  ; Надеюсь rdi не успел поменяться
+  ; заполняем память
+  push rbx
+  mov rbx, [rbp - 32]
+  mov rcx, [rbp - 40]
+  mov rax, 777 ; специально такое число, чтобы выделялось
+  .next_row:
+  push rcx
+  mov rcx, [rbp - 32]
+  .fill:
+  mov [rdi], rax
+  lea rdi, [rdi + 4]
+  loop .fill
+  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
+  pop rcx
+  loop .next_row
+  pop rbx
+
+  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
+  RPOP_M rdi, rsi, rdx
+  pop rbp
+  ret

04-addr-methods/task3.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+#include <time.h>
+
+extern void fill_arr1(int* arr, size_t size, size_t row_count);
+extern void fill_arr2(int* arr, size_t size, size_t row_count);
+
+double measure_fill_time(void(*function)(int*, size_t, size_t), int* arr, size_t size, size_t row_count)
+{
+  const size_t times = 10000000;
+  clock_t begin = clock();
+  for (size_t i = 0; i < times; i++)
+  {
+    function(arr, size, row_count);
+  }
+  clock_t end = clock();
+  return (double)(end - begin)/(CLOCKS_PER_SEC);
+}
+
+int main()
+{
+  const int arr_size = 256;
+  int array1[arr_size];
+
+  printf("String methods took %fs to loop 10,000,000 times\n", measure_fill_time(fill_arr1, array1, arr_size, 16));
+
+  for (size_t i = 0; i < arr_size; i++)
+  {
+    printf("%d ", array1[i]);
+  }
+  printf("\b \n");
+
+  int array2[arr_size];
+
+  printf("Lea methods took %fs on to loop 10,000,000 times\n", measure_fill_time(fill_arr2, array2, arr_size, 16));
+  for (size_t i = 0; i < arr_size; i++)
+  {
+    printf("%d ", array2[i]);
+  }
+  printf("\b \n");
+  
+  return 0;
+}
+

04-addr-methods/timer.inc

@@ -0,0 +1,13 @@
+
+section .data
+  str_template: db "Command %s took %lld seconds and %lld nanoseconds to execute 1 000 000 000 times", 10, 0
+  template_len equ $-str_template
+
+  nop_command:        db '`empty loop`', 0
+  reg_command:        db '`inc ebx`', 0
+  rel_reg:            db '`inc byte [rax]`', 0
+  ind_base:           db '`inc byte [rax + rbx]`', 0
+  ind_base_disp:      db '`inc byte [rax + rbx + 122]`', 0
+
+  tick_count:         db 'Last command also took %lli ticks to complete', 10, 0
+