diff --git a/docs_store/opcodes/avr_xml_gen/.gitignore b/docs_store/opcodes/avr_xml_gen/.gitignore
new file mode 100644
index 00000000..4ab73ef6
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/.gitignore
@@ -0,0 +1,3 @@
+intermediate_data/
+*.log
+__pycache__
diff --git a/docs_store/opcodes/avr_xml_gen/AVR-Instruction-Set-Manual-DS40002198A.pdf b/docs_store/opcodes/avr_xml_gen/AVR-Instruction-Set-Manual-DS40002198A.pdf
new file mode 100644
index 00000000..0f2903cf
Binary files /dev/null and b/docs_store/opcodes/avr_xml_gen/AVR-Instruction-Set-Manual-DS40002198A.pdf differ
diff --git a/docs_store/opcodes/avr_xml_gen/README.md b/docs_store/opcodes/avr_xml_gen/README.md
new file mode 100644
index 00000000..e28289d4
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/README.md
@@ -0,0 +1,160 @@
+This is a program for generating avr instructions xml
+
+The rogram uses the avr datasheet, which you can find under [AVR-Instruction-Set-Manual-DS40002198A.pdf](https://ww1.microchip.com/downloads/en/DeviceDoc/AVR-InstructionSet-Manual-DS40002198.pdf)
+
+The whole programm is split into 4 stages:
+
+1. Data markers
+2. Data extraction
+3. Data analysis
+4. Xml generation
+
+For gui, [tkinter](https://docs.python.org/3/library/tkinter.html) is used.
+
+# 1. Data managinig and structuring
+
+Stored in `core/data_processing`.
+There are series of unfortunate titles such as `data_processing` or `data_processing.data_management`,
+because they don't point to the exact purpose of classes. This can be changed in
+the future, but so far, fate has decided.
+
+## 1.1 Storing instruction and its forms
+
+Each instruction form has several aspects. They are:
+
+1. Mnemonic ('name' in xml)
+2. Version (version of avr architecture)
+3. Description ('summary' in xml)
+4. Operands
+5. SREG (status registers)
+6. Opcode
+
+I extracted aspects 1, 3, and 4 from tables and 1, 2, 5, and 6 from chapters (datasheet,
+chapter 5). This is merged, so now 3 and 4 is stored as `table data`', while 5 and
+6  are stored as `chapter data`. Sometimes you can see subchapter instead of chapter
+because at the very beginning I wanted to name it 'subchapter'. In some cases, division
+into the chapter and subchapter makes sence (in the data extraction stage). Even
+though 2 (version) is extracted from a chapter, the version is chapter-data independent,
+and it was just convenient to extract versions from chapter.
+
+There is the class `data_management.InstructionForm` for storing `mnemonic`, `version`,
+`table_data` and `chapter_data`. It inherits `data_management.StrictDictionary`
+which is the same as default dictionary, but with fixed keys. This is helpful,
+as python points tells if there are wrong or missing keys.
+
+Instruction is stored as a dictionary with `str -> list[InstructionForm]`, where
+`str` is the instruction name.
+
+## 1.2 Context
+
+`data_management.Context` stores all data that could be used by stages. It stores
+instruction data markers, instruction data extracted from datasheet, parsed instruction
+data (instruction forms), and even the datasheet file name.
+
+Context has dictionary and works in the key-value concept, but with one feature:
+keys are data type. So it could store only one copy of particular data. This was
+better than a dictionary with str names or something else. During development, it
+became clear that this needed to be changed for Aliases.
+
+Some unique data (e.g `ExtractedInstructionData`, `ProcessedInstructionData`) could
+just be an `Alias`, but they would have been the same key of type `Alias` if I have
+left as it was. A future improvement could be to make context distinguish different
+aliases as keys.
+
+## 1.3 Ambiguous data
+
+In `ambiguous_data.py` you can see several default data types analogs (`dict`,
+`list`, `forzenset`) but with the 'Ambiguous' prefix.
+
+During the data extraction it became clear that it is useful to determine if a list
+or set has more than one object. It was too often so I decided to create the same
+classes but with a `is_ambiguous()` method and special output: it prints 'Ambiguous'
+if data is ambiguous. The dictionary is ambiguous if it has ambiguous value or key.
+The whole extracted instruction data is `AmbiguousDict[AmbiguousFrozen, AmbiguousList]`.
+
+## 1.4 Other random classes
+
+Observer and Subject:
+I used the observer pattern for stages, so I just shoved these classes here :)
+
+DataManager:
+Is used by stage (2). It has `request()` method. The implementation depends on a
+particular class. The biggest example of this is in `core/stages/data_analysis/instruction_forms_manager.py`.
+
+# 2. Stages
+
+All related to stages is stored in `core/stages`.
+
+## 2.1 The main tasks of the stages
+
+1. The data markers stage customizes the instruciton data markers that determine
+   what is useful data in the datasheet. It isn't used at this time because data extraction
+   stage isn't completed. Details are written in '2 Data extraction'. If you want to
+   see what is created for data markers, replace `app.after(100, stage2.execute)` with
+   `app.after(100, stage1.execute)`. This is a demonstration of a field selector. It
+   can catch pdf objects like images, tables and words and access to all of their attributes.
+
+2. The data extraction stage uses data markers created in first stage to extract
+   instruction data from the datasheet. This stage doesn't have a modular structure
+   and doesn't use markers, so it should be remade.
+
+3. Data analysis converts extracted data for direct xml compilation. This data is
+   a dictionary with instruction names as keys and lists of instruction forms as values.
+   Datasheet data isn't always ambiguous, which can be resolved by two ways: manually
+   by selecting needed options or programmatically by adding code to handle specific
+   cases. The first option is preferred.
+
+4. Xml generation speaks for itself. It uses processed data from the data analysis
+   stage.
+
+## 2.2 Stage concept itself
+
+Basic stage classes stored in `stage.py`
+
+Summary:
+
+The whole programm is split into stages. Each stage has next stage (it could be None),
+`execute()`, and `try_complete()` methods. It require `Context` (1.2) for initialization.
+
+At the very beginning we `execute()` the first stage. By default, the stage tries
+to be completed by `try_complete()` after the `<<Complete>>` event. If it is completed,
+the stage executes the next stage. Otherwise, its work is continued.
+
+`Stage` also has a `permanently_completed` variant. This is needed for `BidirectionStage`,
+which could go forwards and back. If `Stage` is permanently completed, it can't be
+`execute()`d.
+
+More details:
+In addition to the `Stage` class, there is also `StageTask`, `StageGUI` and `BidirectionalStage`.
+`StageTask` is used by `try_complete()` to check if completion conditions are satisfied
+by method `is_completed()`. It also requires `Context`.
+
+`StageGUI` is used if we need gui :). It has `enable()` and `disable()` methods.
+It requires `DataManager`. (1.4) `Stage.execute()` calls `StageGUIStage` GUI generates
+a `<<Complete>>` event. After generating this event, `Stage` executes `try_complete()`.
+
+In fact, `StageTask` and `StageGUI` are optional. See `xml_generation.py`.
+
+`BidirectionalStage` is the same as default stage, except that it also has the previous_stage.
+It inherits `Stage`.
+
+## 2.3 Stages implementation
+
+1. Data markers has one stage `SettingHeader`. It determines the height of the pdf
+   header. This is just a demonstration. For gui,`PDFRegionSelector`is used.
+
+2. Data extraction has one big process of data extraction, no more. As I mentioned
+   in 2.1, it could be cleaned up. It has gui with a 'waiting' caption.
+
+3. Data analysis has `InstructionBuilding` class. It is `BidirectionalStage`. An
+   `InstructionBuilding` instance is created for each instruction. It automatically
+   generates one singular instruction form and completes itself, if instruction data
+   isn't ambiguous (not `is_ambiguous()`, see `AmbiguousData` in 1.3), otherwise its
+   GUI is opened. In the GUI, the user creates forms and selects correct form aspects.
+   A future imrprovement could be adding saving for selected options. In `app.py` you
+   can see `InstructionBuildingInitializing`. It is needed for creating `InstructionBuilding`
+   instances.
+
+4. Xml generation has `XMLGeneration` which uses `InstructionXMLBuilder`. It is a
+   realy simple stage even without GUI and Task (task should be added to check if all
+   is good)
diff --git a/docs_store/opcodes/avr_xml_gen/app.py b/docs_store/opcodes/avr_xml_gen/app.py
new file mode 100644
index 00000000..032e0be6
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/app.py
@@ -0,0 +1,99 @@
+from core.logging import setup_logging
+setup_logging()
+
+from core.data_processing import Context, InstructionDataMarkers, SourceInfo, ExtractedInstructionsData, ProcessedInstructionsData
+from core.stages.data_markers import SettingHeader
+from core.stages.data_extraction import DataExtraction
+from core.stages.data_analysis import InstructionBuilding
+from core.stages.xml_generation import XMLGeneration
+from core.stages import Stage, BidirectionalStage, StageGUI, StageTask
+from core.data_processing.data_management import DataManager
+import tkinter as tk
+import os
+
+
+class InstructionBuildingInitializingTask(StageTask):
+    def is_completed(self) -> bool:
+        return True
+
+
+class InstructionBuildingInitializingGUI(StageGUI):
+    def __init__(self, master=None, cnf=..., **kwargs) -> None:
+        super().__init__(None, master, cnf, **kwargs)
+        self.__setup_ui()
+        self.__setup_bindings()
+
+    def __setup_ui(self):
+        self._label = tk.Label(self, text='Now we need to make up the forms\n' \
+                                          'Some instructions data is ambiguous\n' \
+                                          'In that case you need to make instruction froms manually'
+                               )
+        self._button = tk.Button(self, text='Resolve ambiguoity')
+        self._label.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self._button.pack(side=tk.BOTTOM, fill=tk.X, expand=True)
+
+    def __setup_bindings(self):
+        self._button.config(command=lambda: self.event_generate('<<Complete>>'))
+
+
+class InstructionBuildingInitializing(Stage):
+    def __init__(self, stages: set[Stage], context: Context, master=None, cnf=..., **kwargs) -> None:
+        super().__init__(context, master, cnf, **kwargs)
+        self.set_gui(InstructionBuildingInitializingGUI())
+        self.set_task(InstructionBuildingInitializingTask(self._context))
+        self._stages = stages
+
+    def execute(self) -> None:
+        extracted_data = self._context[ExtractedInstructionsData]
+        stages: list[BidirectionalStage] = []
+        for instruction_name in extracted_data.keys():
+            stages.append(InstructionBuilding(instruction_name, self._context))
+        for i in range(1, len(stages)):
+            stages[i-1].set_next(stages[i])
+            stages[i].set_previous(stages[i-1])
+        stages[-1].set_next(self._next_stage)
+        self._next_stage = stages[0]
+        self._stages.update(stages)
+        if self._gui is not None:
+            self._gui.enable(expand=True)
+
+
+class EndStageGUI(StageGUI):
+    def __init__(self, data_manager: DataManager | None = None, master=None, cnf=..., **kwargs) -> None:
+        super().__init__(data_manager, master, cnf, **kwargs)
+        self.label = tk.Label(self, text='Work is completed')
+        self.label.pack()
+
+
+class EndStage(Stage):
+    def __init__(self, context: Context, master=None, cnf=..., **kwargs) -> None:
+        super().__init__(context, master, cnf, **kwargs)
+        self._gui = EndStageGUI()
+
+
+def main():
+    app = tk.Tk()
+
+    context = Context()
+    context.record(ExtractedInstructionsData())
+    context.record(ProcessedInstructionsData())
+    source_info = SourceInfo()
+    source_info['pdf_path'] = os.path.abspath('./AVR-Instruction-Set-Manual-DS40002198A.pdf')
+    context.record(source_info)
+    context.record(InstructionDataMarkers())
+
+    stages: set[Stage] = set()
+    stage1 = SettingHeader(context)
+    stage2 = DataExtraction(context)
+    stage3 = InstructionBuildingInitializing(stages, context)
+    stage4 = XMLGeneration(context)
+    stage5 = EndStage(context)
+
+    stage1.set_next(stage2)
+    stage2.set_next(stage3)
+    stage3.set_next(stage4)
+    stage4.set_next(stage5)
+    app.after(100, stage2.execute)
+    app.mainloop()
+
+main()
diff --git a/docs_store/opcodes/avr_xml_gen/core/data_processing/__init__.py b/docs_store/opcodes/avr_xml_gen/core/data_processing/__init__.py
new file mode 100644
index 00000000..53ae4be4
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/data_processing/__init__.py
@@ -0,0 +1,2 @@
+from .ambiguous_data import *
+from .data_management import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/data_processing/ambiguous_data.py b/docs_store/opcodes/avr_xml_gen/core/data_processing/ambiguous_data.py
new file mode 100644
index 00000000..30983a09
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/data_processing/ambiguous_data.py
@@ -0,0 +1,92 @@
+from typing import Optional, Collection, Iterable
+from colorama import Fore, init
+from abc import ABC, abstractmethod
+
+init(autoreset = True)
+
+
+class AmbiguousData(ABC):
+    @abstractmethod
+    def is_ambiguous(self) -> bool:
+        pass
+
+
+class AmbiguousList[T](list[T], AmbiguousData):
+    def __init__(self, single_data: Optional[T] = None):
+        if single_data is None:
+            super().__init__()
+        else:
+            super().__init__([single_data])
+
+    def append(self, single_data: T) -> None:
+        if single_data in self:
+            return
+        else:
+            super().append(single_data)
+
+    def extend(self, iterable: Iterable[T]) -> None:
+        new_data = super().extend(iterable)
+        super().clear
+        if not new_data:
+            return
+        new_data = set(new_data)
+        super().extend(new_data)
+
+    def is_ambiguous(self) -> bool:
+        if not self:
+            return False
+        elif any(isinstance(single_data, AmbiguousData) for single_data in self):
+            return True
+        return len(self) > 1
+
+    def __repr__(self) -> str:
+        if self.is_ambiguous():
+            return Fore.RED + 'Ambiguous:' + Fore.RESET + f'{super().__repr__()}'
+        elif not self:
+            return f'Empty'
+        else:
+            return f'{self[0]}'
+
+
+class AmbiguousDict[S, T](dict[S, T], AmbiguousData):
+    def is_ambiguous(self) -> bool:
+        if not self:
+            return False
+        elif any(isinstance(single_data, AmbiguousData) and single_data.is_ambiguous() for single_data in self.values()):
+            return True
+        else:
+            return False
+
+    def __repr__(self) -> str:
+        if not self:
+            return f'Empty'
+        elif not self.is_ambiguous():
+            return f'{super().__repr__()}'
+        else:
+            return Fore.RED + 'Ambiguous:' + Fore.RESET + f'{super().__repr__()}'
+
+
+class AmbiguousFrozen[T](frozenset[T], AmbiguousData):
+    def __new__(cls, data: Collection[T]):
+        return super().__new__(cls, data)
+
+    def is_ambiguous(self) -> bool:
+        return len(self) > 1
+
+    def __repr__(self) -> str:
+        if self.is_ambiguous():
+            return Fore.RED + 'Ambiguous:' + Fore.RESET + f'{sorted(self)}'
+        else:
+            return f'{next(iter(self), None)}'
+
+    def __or__(self, other) -> 'AmbiguousFrozen[T]':
+        return AmbiguousFrozen(super().__or__(other))
+
+    def __and__(self, other) -> 'AmbiguousFrozen[T]':
+        return AmbiguousFrozen(super().__and__(other))
+
+    def __xor__(self, other) -> 'AmbiguousFrozen[T]':
+        return AmbiguousFrozen(super().__xor__(other))
+
+    def __sub__(self, other) -> 'AmbiguousFrozen[T]':
+        return AmbiguousFrozen(super().__sub__(other))
diff --git a/docs_store/opcodes/avr_xml_gen/core/data_processing/data_management.py b/docs_store/opcodes/avr_xml_gen/core/data_processing/data_management.py
new file mode 100644
index 00000000..2dc4b5a0
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/data_processing/data_management.py
@@ -0,0 +1,139 @@
+from abc import ABC, abstractmethod
+from typing import OrderedDict, Any
+import logging
+from .ambiguous_data import AmbiguousDict
+import weakref
+
+logger=logging.getLogger(__name__)
+
+# Dictionary which could have only particular keys
+# These keys are placed in `valid_keys`
+# Class guarantees setting all keys from valid_keys even if they weren't passed in `__init__`
+# Also it has unique id. It is used for `core/stages/data_analysis/instruction_building_manager`
+class StrictDictionary(dict):
+    valid_keys = ()
+
+    def __init__(self, *args, **kwargs):
+        for k in kwargs.keys():
+            if not self.is_valid_aspect_name(k):
+                return
+        super().__init__(*args, **kwargs)
+        for k in self.valid_keys:
+            if k not in self.keys():
+                self[k] = None
+        self._id = hash(id(self))
+
+    def id(self):
+        return self._id
+
+    def update(self, *args, **kwargs):
+        for k in kwargs.keys():
+            if not self.is_valid_aspect_name(k):
+                return
+        super().update(*args, **kwargs)
+
+    def __setitem__(self, k, v):
+        if not self.is_valid_aspect_name(k):
+            return
+        super().__setitem__(k, v)
+
+    def is_valid_aspect_name(self, k: str) -> bool:
+        if k not in self.valid_keys:
+            logger.error(f'Try to set unvalid key: {k}')
+            return False
+        return True
+
+
+
+class SourceInfo(StrictDictionary):
+    valid_keys = ('pdf_path',)
+
+class InstructionDataMarkers(StrictDictionary):
+    valid_keys = ('header_height',)
+
+class InstructionForm(StrictDictionary):
+    valid_keys = ('mnemonic',
+                  'version',
+                  'table_data',
+                  'chapter_data',
+                  )
+
+class ExtractedInstructionsData(OrderedDict[str, AmbiguousDict]):
+    pass
+
+class ProcessedInstructionsData(OrderedDict[str, list[InstructionForm]]):
+    pass
+
+
+class DataManager(ABC):
+    # Request is dictionary
+    # By default 'type':... is mandaotry item of request
+    # Valid values for 'type' are in valid_request_keys
+    valid_request_keys: dict = {'type': ()}
+
+    # log parameter determines whether to log or not to log
+    def _is_key_in_request(self, request: dict, request_key: str, log=True) -> bool:
+        if request_key not in request.keys():
+            if log: logger.error(f'Invalid request {request}; expected key {request_key}')
+            return False
+        return True
+
+    # it is named with 'valided' word instead of 'valid' due to the problems wit aspects key in InstructionFormsManager
+    # i should change logic someday...
+    def _is_request_key_valided(self, request: dict, request_key: str, log=True) -> bool:
+        if not self._is_key_in_request(request, request_key, log):
+            return False
+        if request[request_key] not in self.valid_request_keys[request_key]:
+            if log: logger.error(f'Invalid request {request}; {request_key}: {request[request_key]} is invalid')
+            return False
+        return True
+
+    @abstractmethod
+    def is_request_valid(self, request: dict) -> bool:
+        pass
+
+    @abstractmethod
+    def request(self, request: dict) -> None | object:
+        pass
+
+
+class Observer(ABC):
+    @abstractmethod
+    def update(self, message=None):
+        pass
+
+
+class Subject:
+    def __init__(self):
+        self._observers_ref: list[weakref.ReferenceType[Observer]] = []
+
+    def notify(self, message=None):
+        for observer in self._observers_ref:
+            observer().update(message)
+
+    def attach(self, observer: Observer):
+        if all(observer != wr() for wr in self._observers_ref):
+            self._observers_ref.append(weakref.ref(observer))
+
+    def detach(self, observer: Observer):
+        self._observers_ref[:] = [wr for wr in self._observers_ref if wr() is not observer]
+
+
+# Stores objects of any type. Type itself is access key to the object
+# e.g. require(int) returns variable with type int
+class Context:
+    def __init__(self):
+        self._data_dict: dict = {}
+
+    def record(self, data):
+        data_type = type(data)
+        if data_type in self._data_dict.keys():
+            logger.debug(f'Data overwriting: {self._data_dict[data_type]} -> {data}')
+        self._data_dict[data_type] = data
+
+    # returns value with data_type type. e.g `value = require(data_type), type(value) == data_type`
+    def __getitem__(self, data_type: type) -> Any:
+        if not data_type in self._data_dict.keys():
+            logger.debug(f'Data acess failed: {data_type}')
+            return None
+        return self._data_dict[data_type]
diff --git a/docs_store/opcodes/avr_xml_gen/core/gui/__init__.py b/docs_store/opcodes/avr_xml_gen/core/gui/__init__.py
new file mode 100644
index 00000000..af7c4045
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/gui/__init__.py
@@ -0,0 +1,2 @@
+from .common_gui import *
+from .pdf_region_selector import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/gui/common_gui.py b/docs_store/opcodes/avr_xml_gen/core/gui/common_gui.py
new file mode 100644
index 00000000..ec3bd7ce
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/gui/common_gui.py
@@ -0,0 +1,213 @@
+import tkinter as tk
+from typing import Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ScrollListbox(tk.Listbox):
+    def __init__(self, master=None, cnf={}, **kwargs):
+        # super().__init__(master, cnf, **kwargs)
+        # make some trick
+        self._frame = tk.Frame(master)
+        super().__init__(self._frame, cnf, selectmode=tk.SINGLE, **kwargs)
+        super().pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        # setup scrollbar
+        self._vscrollbar = tk.Scrollbar(self._frame, orient=tk.VERTICAL, command=self.yview)
+        self._vscrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        super().config(yscrollcommand=self._vscrollbar.set)
+        # call custom events
+        self.bind('<KeyPress-j>', lambda event: self.event_generate('<<Down>>'), add='+')
+        self.bind('<Down>', lambda event: self.event_generate('<<Down>>'), add='+')
+        self.bind('<KeyPress-k>', lambda event: self.event_generate('<<Up>>'), add='+')
+        self.bind('<Up>', lambda event: self.event_generate('<<Up>>'), add='+')
+        # init default events
+        self.bind('<<ListboxSelect>>', self.__on_item_click, add='+')
+        self.bind('<<Down>>', self.__select_next, add='+')
+        self.bind('<<Up>>', self.__select_previous, add='+')
+        # init ind
+        self.current_ind = None
+
+    # for correct work
+    def pack_configure(self, cnf={}, **kwargs):
+        self._frame.pack_configure(cnf, **kwargs)
+
+    pack = configure = config = pack_configure
+
+    def pack_forget(self):
+        self._frame.pack_forget()
+
+    forget = pack_forget
+
+    def pack_info(self):
+        return self._frame.pack_info()
+
+
+    info = pack_info
+    # magic is complete
+
+    def __on_item_click(self, event):
+        selection = event.widget.curselection()
+        if selection and (selection[0] is not None):
+            self.current_ind = selection[0]
+            self.select_line(self.current_ind)
+
+    def __select_next(self, event):
+        if self.current_ind is None:
+            self.current_ind = 0
+        else:
+            self.current_ind = (self.current_ind + 1) % self.size()
+        self.select_line(self.current_ind)
+
+    def __select_previous(self, event):
+        if self.current_ind is None:
+            self.current_ind = 0
+        else:
+            self.current_ind = (self.current_ind - 1) % self.size()
+        self.select_line(self.current_ind)
+
+    def select_line(self, line_ind: int):
+        if (line_ind < 0 or
+            line_ind >= self.size()):
+            return
+        self.select_clear(0, tk.END)
+        self.select_set(line_ind)
+        self.activate(line_ind)
+
+    def set_current_line_highlight(self, enable: bool):
+        if not self.current_ind is None:
+            self.set_line_highlight(self.current_ind, enable)
+
+    def set_line_highlight(self, line_ind: int, enable: bool):
+        if (line_ind < 0 or
+            line_ind >= self.size()):
+            return
+        if enable:
+            self.itemconfig(line_ind, bg='lavender')
+        else:
+            self.itemconfig(line_ind, bg='white')
+
+    def clear_highlight(self):
+        for line_ind in range(0,self.size()):
+            self.itemconfig(line_ind, bg='white')
+
+
+class OptionSelector(tk.Frame):
+    def __init__(self, master=None, cnf={}, **kwargs):
+        super().__init__(master, cnf, **kwargs)
+
+        self._label = tk.Label(self)
+        self._label.pack(side=tk.TOP, fill=tk.X)
+
+        self._scroll_listbox = ScrollListbox(self, **kwargs)
+        self._scroll_listbox.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
+        self._selected_line_ind = self._scroll_listbox.current_ind
+
+        self._scroll_listbox.bind('<Return>', self.select_current_line, add='+')
+        self._scroll_listbox.bind('<Double-Button-1>', self.select_current_line, add='+')
+        self._scroll_listbox.bind('<FocusOut>', self.__on_focus_out, add='+')
+
+    def set_name(self, name: str):
+        self._label.config(text=name)
+
+    def insert(self, index, *elements):
+        self._scroll_listbox.insert(index, *elements)
+
+    def delete(self, first, last = None):
+        self._scroll_listbox.delete(first, last)
+
+    def get_current(self) -> Any:
+        current_ind = self._scroll_listbox.curselection()
+        return self._scroll_listbox.get(current_ind)
+
+    def get_selected(self) -> Any:
+        if not self._selected_line_ind is None:
+            return self._scroll_listbox.get(self._selected_line_ind)
+
+    def get_current_ind(self) -> int | None:
+        return self._scroll_listbox.current_ind
+
+    def get_selected_ind(self) -> int | None:
+        return self._selected_line_ind
+
+    def select_line(self, line_ind: int | None):
+        if self._selected_line_ind is not None:
+            self._scroll_listbox.set_line_highlight(self._selected_line_ind, False)
+        if isinstance(line_ind, int):
+            if line_ind < 0 or line_ind > self._scroll_listbox.size():
+                logger.error('Line ind to select is out of range')
+                return
+            self._scroll_listbox.set_line_highlight(line_ind, True)
+        self._selected_line_ind = line_ind
+
+    def select_current_line(self, event=None):
+        if not self._selected_line_ind is None:
+            self._scroll_listbox.set_line_highlight(self._selected_line_ind, False)
+        self._scroll_listbox.set_current_line_highlight(True)
+        self._selected_line_ind = self._scroll_listbox.current_ind
+
+    def update(self):
+        self._scroll_listbox.clear_highlight()
+        if not self._selected_line_ind is None:
+            self._scroll_listbox.set_line_highlight(self._selected_line_ind, True)
+
+    def __on_focus_out(self, event=None):
+        self._scroll_listbox.current_ind = self._selected_line_ind
+
+
+class InfoDisplay(tk.Frame):
+    def __init__(self, master=None, **kwargs):
+        super().__init__(master)
+        kwargs.setdefault('state', tk.DISABLED)
+
+        self.label = tk.Label(self)
+        self.label.pack(side=tk.TOP, fill=tk.X)
+
+        self.text = tk.Text(self, **kwargs)
+        self.text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        self.scrollbar = tk.Scrollbar(self, orient=tk.VERTICAL, command=self.text.yview)
+        self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+
+        self.text.config(yscrollcommand=self.scrollbar.set)
+
+    def set_name(self, name: str):
+        self.label.config(text=name)
+
+    def insert(self, index, *elements):
+        self.text.config(state=tk.NORMAL)
+        self.text.insert(index, *elements)
+        self.text.config(state=tk.DISABLED)
+
+    def clear(self):
+        self.text.config(state=tk.NORMAL)
+        self.text.delete(1.0, tk.END)
+        self.text.config(state=tk.DISABLED)
+
+
+#Button for changing stage
+class NextButton(tk.Button):
+    # `epoint` - event point
+    # Button generates event `<<Complete>>` to point `Stage` to change `Stage`
+    # But `Stage` listens to `StageGUI`, not concrete button. Stage couldn't hear `<<Complete>>` event
+    # if it is generated only inside button, due `tkinter` events logic.
+    # So Event needs to be generated inside `StageGUI`. And there are two options:
+    # 1. `StageGUI` listens to buttons `<<Complete>>` and generates `<<Complete>>` itself
+    # 2. Button generates `<<Complete>>` directly inside `Stage` (`epoint` is needed)
+    # I chose 2 because I liked it more.
+    def __init__(self, master=None, epoint=None, **kwargs):
+        self._epoint = self if epoint is None else epoint
+        super().__init__(master, text='next', command=lambda: self._epoint.event_generate('<<Complete>>'), **kwargs)
+
+
+# The same as `NextButton`, but with additional 'direction': back (`<<GoBack>>` event)
+# It might seem weird to get event `<<Complete>>` for the `NextButton`,
+# but `<<GoBack>>` for the `PreviousButton`. But fate decided so...
+class BackNextButtons(tk.Frame):
+    def __init__(self, master=None, epoint=None, **kwargs):
+        super().__init__(master, **kwargs)
+        self._epoint = self if epoint is None else epoint
+
+        self.back_button = tk.Button(self, text='back', command=lambda: self._epoint.event_generate('<<GoBack>>'))
+        self.next_button = tk.Button(self, text='next', command=lambda: self._epoint.event_generate('<<Complete>>'))
+        self.back_button.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        self.next_button.pack(side=tk.RIGHT, fill=tk.X, expand=True)
diff --git a/docs_store/opcodes/avr_xml_gen/core/gui/pdf_region_selector.py b/docs_store/opcodes/avr_xml_gen/core/gui/pdf_region_selector.py
new file mode 100644
index 00000000..4e8331a0
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/gui/pdf_region_selector.py
@@ -0,0 +1,177 @@
+import tkinter as tk
+from tkinter import filedialog
+from PIL import ImageTk
+import pdfplumber
+from typing import Iterable
+
+
+# The name speaks for itself.
+# Selected items stores in _selected_elements
+# Pdf page should be centered, but I forgot to make it
+class PDFRegionSelector(tk.Frame):
+    # There is added my own key: `pdf_selection`
+    # It determines if pdf choosing button will be created
+    def __init__(self, master=None, cnf={}, pdf_selection=True, **kwargs):
+        super().__init__(master, cnf, **kwargs)
+
+        self.__setup_ui(pdf_selection)
+        self.__setup_bindings(pdf_selection)
+
+        self._pdf = None
+        self._page = None
+        elements = {'word', 'line', 'curve'}
+        self._page_elements = {e: [] for e in elements}
+        self._selected_elements = {e: [] for e in elements}
+
+        self._current_page_ind = 0
+        # pdf page height / image height
+        self._scale_factor = 1
+        self._highlight_color = 'blue'
+
+
+    def __setup_ui(self, pdf_selection=True):
+        self._canvas = tk.Canvas(self)
+        self._canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+
+        self._button_frame = tk.Frame(self)
+        self._button_frame.pack(side=tk.BOTTOM, fill=tk.X)
+        button_pack = {'side': tk.LEFT,
+                       'fill': tk.X,
+                       'expand': True,
+                       }
+        if pdf_selection:
+            self._load_button = tk.Button(self._button_frame, text='Load PDF')
+            self._load_button.pack(button_pack)
+        self._prev_page_button = tk.Button(self._button_frame, text='Previous Page')
+        self._prev_page_button.pack(button_pack)
+        self._next_page_button = tk.Button(self._button_frame, text='Next Page')
+        self._next_page_button.pack(button_pack)
+
+
+    def __setup_bindings(self, pdf_selection=True):
+        self._canvas.bind("<ButtonPress-1>", self.__start_rectangle)
+        self._canvas.bind("<B1-Motion>", self.__draw_rectangle)
+        self._canvas.bind("<ButtonRelease-1>", self.__finish_rectangle)
+        self._canvas.bind('<Configure>', self.show_page)
+
+        if pdf_selection:
+            self._load_button.config(command=self.load_pdf)
+        self._prev_page_button.config(command=self.prev_page)
+        self._next_page_button.config(command=self.next_page)
+
+
+    def __start_rectangle(self, event):
+        self._canvas.delete('selection')
+        self._rect_start = (event.x, event.y)
+        self._rect_ind = self._canvas.create_rectangle(event.x, event.y, event.x, event.y, fill=self._highlight_color, stipple='gray12')
+
+
+    def __draw_rectangle(self, event):
+        if not self._rect_ind:
+            return
+
+        self._canvas.coords(self._rect_ind, self._rect_start[0], self._rect_start[1], event.x, event.y)
+        rect = self._canvas.coords(self._rect_ind)
+        self._canvas.delete('selection')
+        self.__select_internal_elements(rect)
+
+
+    def __select_internal_elements(self, image_rect: Iterable):
+        _page_rect = tuple(t * self._scale_factor for t in image_rect)
+        for e_name in self._page_elements.keys():
+            elements = self.__get_internal_elements(_page_rect, e_name)
+            self._selected_elements[e_name] = elements
+
+        for elements in self._selected_elements.values():
+            self.__highlight_elements(elements, self._highlight_color)
+
+
+    def __get_internal_elements(self, _page_rect: Iterable, element_name: str) -> list:
+        if not self._page:
+            return []
+        x0, y0, x1, y1 = _page_rect
+        internal_elements = [
+            e for e in self._page_elements[element_name]
+            if not (x0 > e['x1'] or
+                    x1 < e['x0'] or
+                    y0 > e['bottom'] or
+                    y1 < e['top'])
+        ]
+        return internal_elements
+
+
+    def __highlight_elements(self, elements: Iterable, color: str):
+        for e in elements:
+            x0 = e['x0'] / self._scale_factor
+            y0 = e['top'] / self._scale_factor
+            x1 = e['x1'] / self._scale_factor
+            y1 = e['bottom'] / self._scale_factor
+            self._canvas.create_rectangle(x0, y0, x1, y1, fill=color, tags='selection', stipple='gray25')
+
+
+    def __finish_rectangle(self, event):
+        self._canvas.delete(self._rect_ind)
+        self.event_generate('<<Select>>')
+
+
+    def show_page(self, event=None):
+        if self._pdf and 0 <= self._current_page_ind < len(self._pdf.pages):
+            self._page = self._pdf.pages[self._current_page_ind]
+            self._page_elements['word'] = self._page.extract_words()
+            objects = self._page.objects
+            self._page_elements['curve'] = objects['curve'] if 'curve' in objects.keys() else []
+            self._page_elements['line'] = objects['line'] if 'line' in objects.keys() else []
+            self.__display_page_image()
+
+
+    def __display_page_image(self):
+        if not self._page:
+            return
+
+        self._scale_factor = self._page.height / self._canvas.winfo_height()
+
+        page_image = self._page.to_image(resolution=300).original
+        new_height = self._canvas.winfo_height()
+        aspect_ratio = self._page.width / self._page.height
+        new_width = int(new_height * aspect_ratio)
+        page_image = page_image.resize((new_width, new_height))
+
+        self._image = ImageTk.PhotoImage(image=page_image)
+        self._canvas.delete('all')
+        self._canvas.create_image(0, 0, anchor=tk.NW, image=self._image)
+
+
+    def set_pdf(self, pdf_path: str):
+        self._pdf = pdfplumber.open(pdf_path)
+        self._current_page_ind = 0
+        self.show_page()
+
+
+    def load_pdf(self):
+        pdf_path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])
+        if pdf_path:
+            self.set_pdf(pdf_path)
+
+
+    def next_page(self):
+        if self._pdf is None:
+            return
+        self._current_page_ind += 1
+        self._current_page_ind %= len(self._pdf.pages)
+        self.show_page()
+
+
+    def prev_page(self):
+        if self._pdf is None:
+            return
+        self._current_page_ind -= 1
+        self._current_page_ind %= len(self._pdf.pages)
+        self.show_page()
+
+
+    def set_highlight_color(self, color: str):
+        self._highlight_color = color
+
+
+    def get_selected_elements(self):
+        return self._selected_elements
diff --git a/docs_store/opcodes/avr_xml_gen/core/logging/__init__.py b/docs_store/opcodes/avr_xml_gen/core/logging/__init__.py
new file mode 100644
index 00000000..f10b8a7e
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/logging/__init__.py
@@ -0,0 +1 @@
+from .logging_config import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/logging/colored_formatter.py b/docs_store/opcodes/avr_xml_gen/core/logging/colored_formatter.py
new file mode 100644
index 00000000..4b5d1fcd
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/logging/colored_formatter.py
@@ -0,0 +1,28 @@
+import logging
+from colorama import Fore, init
+
+# I wanted simple colored output for logs
+# I found out answers in stack owerflow, but didn't like them
+# Their Formatter modifications seemed crooked to me.
+# I saw library coloredlogs, but didn't realise how to carefully use it
+# So I opened logging module source code and slightly overloaded format function
+class ColoredFormatter(logging.Formatter):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.FORMAT_COLORS = {
+            logging.DEBUG: Fore.RESET,
+            logging.INFO: Fore.BLUE,
+            logging.WARNING: Fore.YELLOW,
+            logging.ERROR: Fore.RED,
+            logging.CRITICAL: Fore.RED,
+        }
+
+    def format(self, record) -> str:
+        s = super().format(record)
+        s = self.FORMAT_COLORS[record.levelno] + s + Fore.RESET
+        return s
+
+    def setLevelColor(self, levelno: int, color: str):
+        if levelno not in self.FORMAT_COLORS.keys():
+            raise RuntimeError(f'levelno is incorrect ({levelno})')
+        self.FORMAT_COLORS[levelno] = color
diff --git a/docs_store/opcodes/avr_xml_gen/core/logging/logging_config.py b/docs_store/opcodes/avr_xml_gen/core/logging/logging_config.py
new file mode 100644
index 00000000..d9af79c4
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/logging/logging_config.py
@@ -0,0 +1,36 @@
+import logging
+import logging.config
+from .colored_formatter import ColoredFormatter
+
+
+def setup_logging():
+    log_config = {
+        'version': 1,
+        'formatters': {
+            'custom': {
+                '()': ColoredFormatter,
+                'format': '%(asctime)s | %(levelname)s | %(name)s | %(message)s'
+            },
+        },
+        'handlers': {
+            'file': {
+                'level': 'DEBUG',
+                'class': 'logging.FileHandler',
+                'filename': 'app.log',
+                'formatter': 'custom',
+            },
+            'console': {
+                'level': 'INFO',
+                'class': 'logging.StreamHandler',
+                'formatter': 'custom',
+            },
+        },
+        'loggers': {
+            '': {
+                'handlers': ['file', 'console'],
+                'level': 'DEBUG',
+            },
+        }
+    }
+    logging.config.dictConfig(log_config)
+    logging.getLogger("pdfminer").setLevel(logging.WARNING)
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/__init__.py b/docs_store/opcodes/avr_xml_gen/core/stages/__init__.py
new file mode 100644
index 00000000..93feaaa6
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/__init__.py
@@ -0,0 +1 @@
+from .stage import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/__init__.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/__init__.py
new file mode 100644
index 00000000..61a6b9d4
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/__init__.py
@@ -0,0 +1,5 @@
+from .data_analysis import *
+from .instruction_forms_manager import InstructionFormsManager, InstructionParser
+from .instruction_building_manager import InstructionBuildingManager
+from .gui.form_aspects_selector import FormAspectsSelector
+from .gui.instruction_form_selector import InstructionFormSelector
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/data_analysis.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/data_analysis.py
new file mode 100644
index 00000000..de74bba2
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/data_analysis.py
@@ -0,0 +1,81 @@
+# internal
+from .gui.instruction_form_selector import InstructionFormSelector
+from .gui.form_aspects_selector import FormAspectsSelector
+from .instruction_building_manager import InstructionBuildingManager
+
+# external
+from core.stages import BidirectionalStage, StageGUI, StageTask
+from core.gui.common_gui import BackNextButtons
+from core.data_processing.data_management import Context, ExtractedInstructionsData, InstructionForm, ProcessedInstructionsData
+from core.data_processing.ambiguous_data import AmbiguousDict
+import logging
+import tkinter as tk
+from tkinter import ttk
+
+
+logger = logging.getLogger(__name__)
+
+
+class InstructionBuildingTask(StageTask):
+    def __init__(self, instruction_name: str, context: Context) -> None:
+        super().__init__(context)
+        self._instruction_name = instruction_name
+
+    def is_completed(self) -> bool:
+        processed_data: list[InstructionForm] = self._context[ProcessedInstructionsData][self._instruction_name]
+        return len(processed_data) > 0
+
+
+class InstructionBuildingGUI(StageGUI):
+    def __init__(self, instruction_manager: InstructionBuildingManager, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(instruction_manager, master, cnf, **kwargs)
+        self._tab_control = ttk.Notebook(self)
+        self._forms = InstructionFormSelector(instruction_manager, self._tab_control)
+        self._mnemonic_and_version = FormAspectsSelector(instruction_manager, ['mnemonic', 'version'], self._tab_control)
+        self._table_data = FormAspectsSelector(instruction_manager, ['table_data'], self._tab_control)
+        self._chapter_data = FormAspectsSelector(instruction_manager, ['chapter_data'], self._tab_control)
+        self._tab_control.add(self._forms, text='Instruction forms')
+        self._tab_control.add(self._mnemonic_and_version, text='Mnemonic&Version')
+        self._tab_control.add(self._table_data, text='Table data')
+        self._tab_control.add(self._chapter_data, text='Chapter data')
+        instruction_manager.attach(self._forms)
+        instruction_manager.attach(self._mnemonic_and_version)
+        instruction_manager.attach(self._table_data)
+        instruction_manager.attach(self._chapter_data)
+        self._back_next_buttons = BackNextButtons(self, epoint=self)
+        self._tab_control.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self._back_next_buttons.pack(side=tk.BOTTOM, fill=tk.X)
+
+
+class InstructionBuilding(BidirectionalStage):
+    def __init__(self, instruction_name: str, context: Context, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(context, cnf, **kwargs)
+        self._context[ProcessedInstructionsData][instruction_name] = []
+        storage_location: list[InstructionForm] = self._context[ProcessedInstructionsData][instruction_name]
+        instruction_data: AmbiguousDict = self._context[ExtractedInstructionsData][instruction_name]
+        self._instruction_manager = InstructionBuildingManager(storage_location, instruction_name, instruction_data)
+        self.set_gui(InstructionBuildingGUI(self._instruction_manager, master, cnf, **kwargs))
+        self.set_task(InstructionBuildingTask(instruction_name, self._context))
+
+    def execute(self) -> None:
+        if not self._instruction_manager.is_instruction_ambiguous():
+            request = {'type': 'add', 'target': 'form'}
+            self._instruction_manager.request(request)
+            self._instruction_manager.focus_form(0)
+            request = {'type': 'get', 'target': 'aspects'}
+            aspects = self._instruction_manager.request(request)
+            form_aspects = {}
+            for aspect_name, aspect_data in aspects.items():
+                form_aspects[aspect_name] = aspect_data[0]
+            request = {'type': 'record', 'target': 'form', 'form_ind': 'focused', 'aspects': form_aspects}
+            self._instruction_manager.save()
+            self.permanently_completed = True
+            self._complete()
+        else:
+            request = {'type': 'add', 'target': 'form'}
+            self._instruction_manager.request(request)
+            super().execute()
+
+    def try_complete(self, event=None) -> None:
+        self._instruction_manager.save()
+        return super().try_complete(event)
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/form_aspects_selector.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/form_aspects_selector.py
new file mode 100644
index 00000000..680f61cc
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/form_aspects_selector.py
@@ -0,0 +1,181 @@
+# internal
+from core.data_processing.ambiguous_data import AmbiguousList, AmbiguousDict
+from ..instruction_building_manager import InstructionBuildingManager
+
+# external
+from core.data_processing.data_management import InstructionForm, Observer
+from core.gui.common_gui import OptionSelector, InfoDisplay
+from core.stages.xml_generation import InstructionXMLBuilder
+import tkinter as tk
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+# There are dead naming. For example setup_ui() should be internal method (aka __setup_ui()), but I would like to save overload option.
+# I mean, setup_ui() could be overloaded and executed without overloading __init__().
+# But __init__() is defined in parent, so if it calls __setup_ui() (not setup_ui()), it always calls parents __setup_ui() implementation,
+# instead of child's due to the __ in naming
+# I don't know python, so don't realize how should I name this kind of functions (cinternal, but could be overloaded by inheritor)
+class FormAspectsSelector(tk.Frame, Observer):
+    def __init__(self, instruction_manager: InstructionBuildingManager, aspect_selectors: list[str], master = None, cnf={}, **kwargs):
+        tk.Frame.__init__(self, master, cnf={}, **kwargs)
+        Observer.__init__(self)
+        self._instruction_manager = instruction_manager
+        # aspect could be opcode, SREG (status registers), flags, ...
+        # aspect option - one of the possible aspect values
+        # e.g. SREG could be [1, 0, -, -] or [0, 0, 1, 1] or ...
+        self._aspect_selectors: dict[str, OptionSelector] = {}
+        # each option has str name in listbox and it's value
+        # aspect option is displayed as str in listbox line. But aspect could be
+        # complex data type, so for each aspect option line we need to store
+        # aspect option value. Option line is list ind, option value is list[ind]
+        self._metadata: dict[str, list] = {} # dict[aspect selector id, list]
+        # program saves shoosen aspect opitons for each instruction form
+        self._form_snapshots: dict[int, dict[str, int | None]] = {} # dict[form id, dict[aspect name, int | None]
+        self.__setup_ui(aspect_selectors)
+        self.__setup_bindings()
+
+
+    def __setup_ui(self, aspect_selectors_names: list[str]):
+        # init aspect selectors
+        self._aspect_selectors_area = tk.Frame(self)
+        for aspect_name in aspect_selectors_names:
+            # option_selector and aspect_selector are the same
+            option_selector = OptionSelector(self._aspect_selectors_area)
+            option_selector.set_name('Aspect: ' + aspect_name)
+            self._aspect_selectors[aspect_name] = option_selector
+            self._metadata[aspect_name] = []
+        # fill aspect selectors options
+        request = {'type': 'get', 'target': 'aspects', 'aspects': aspect_selectors_names}
+        aspects_options: dict[str, list] = self._instruction_manager.request(request)
+        for aspect_name, aspect_options in aspects_options.items():
+            for aspect_option in aspect_options:
+                # option_selector and aspect_selector are the same
+                aspect_selector = self._aspect_selectors[aspect_name]
+                aspect_selector.insert(tk.END, aspect_option)
+                self._metadata[aspect_name].append(aspect_option)
+        # init info display
+        self._info_display = InfoDisplay(self)
+        self._info_display.set_name('Result')
+        self._show_preliminar_info()
+        # pack all
+        for aspect_selector in self._aspect_selectors.values():
+            aspect_selector.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self._aspect_selectors_area.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        self._info_display.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
+
+
+    def __setup_bindings(self):
+        for aspect_name, aspect_selector in self._aspect_selectors.items():
+            if not aspect_selector:
+                raise RuntimeError('Aspect is empty')
+            # i don't know how to make it properly without accessing to the internal object of aspect_selector
+            aspect_selector._scroll_listbox.bind('<Return>', lambda event, name=aspect_name: self._select_aspect_option(name), add='+')
+            aspect_selector._scroll_listbox.bind('<Double-Button-1>', lambda event, name=aspect_name: self._select_aspect_option(name), add='+')
+            aspect_selector._scroll_listbox.bind('<<Down>>', lambda event, name=aspect_name: self._show_preliminar_info(name), add='+')
+            aspect_selector._scroll_listbox.bind('<<Up>>', lambda event, name=aspect_name: self._show_preliminar_info(name), add='+')
+            aspect_selector._scroll_listbox.bind('<<ListboxSelect>>', lambda event, name=aspect_name: self._show_preliminar_info(name), add='+')
+
+
+    def _snapshot_form(self, form: InstructionForm):
+        form_id = form.id()
+        if not form_id in self._aspect_selectors:
+            self._form_snapshots[form_id] = {}
+        for aspect_name, aspect_selector in self._aspect_selectors.items():
+            # It is awfull code because instruction_form calls id() method for getting unique id (form_id)
+            # But we get aspect_selector by it's name. It means that we point to objects in different ways
+            # (point to concrete form by form_id, but point to concrete to aspect by it's str name, not id)
+            # I added id() method to the instution_form becasue request() returns copy of instruction_form object
+            # So python's id() function returns different value for different copies, but I need them have the same id
+            self._form_snapshots[form_id][aspect_name] = aspect_selector.get_selected_ind()
+
+
+    def _show_preliminar_info(self, aspect_name=None):
+        request = {'type': 'get', 'target': 'form', 'form_ind': 'focused'}
+        instruction_form = self._instruction_manager.request(request)
+
+        # empty info
+        if instruction_form is None:
+            self._info_display.clear()
+            self._info_display.insert(tk.END, 'Please, choose instruction form')
+            return
+        # wrong logic
+        elif not isinstance(instruction_form, InstructionForm):
+            logger.error(f'Invalid request {request}; expected an InstructionForm, not {type(instruction_form)}')
+            return
+
+        if aspect_name is not None:
+            aspect_option_ind = self._aspect_selectors[aspect_name].get_current_ind()
+            if aspect_option_ind is None:
+                instruction_form[aspect_name] = None
+            else:
+                instruction_form[aspect_name] = self._metadata[aspect_name][aspect_option_ind]
+        instruction_form_str = InstructionXMLBuilder.create_instruction_form_str(instruction_form)
+        self._info_display.clear()
+        self._info_display.insert(tk.END, instruction_form_str)
+
+
+    def _select_aspect_option(self, aspect_name: str):
+        aspect_option_ind = self._aspect_selectors[aspect_name].get_selected_ind()
+        if aspect_option_ind is None:
+            aspect_option = None
+        else:
+            aspect_option = self._metadata[aspect_name][aspect_option_ind]
+        request = {'type': 'record', 'target': 'form', 'form_ind': 'focused', 'aspects': {aspect_name: aspect_option}}
+        self._instruction_manager.request(request)
+
+
+    # here is shitcode
+    def update(self, message=None):
+        # shitcode
+        if message in ('record',
+                           'add',
+                           'delete',
+                           'before_focused_form_changed',
+                           'after_focused_form_changed'
+                           ):
+            # it is used in all cases, but message could be beyond cases
+            # so it requests each update. It isn't good, because it doesn't need do it
+            request = {'type': 'get', 'target': 'form', 'form_ind': 'focused'}
+            focused_form = self._instruction_manager.request(request)
+            if focused_form is None:
+                # clear aspect selector
+                for aspect_selector in self._aspect_selectors.values():
+                    aspect_selector._selected_line_ind = None
+            elif not isinstance(focused_form, InstructionForm):
+                logger.error(f'Invalid request {request}; expected an InstructionForm, not {type(focused_form)}')
+                # clear aspect selector
+                for aspect_selector in self._aspect_selectors.values():
+                    aspect_selector._selected_line_ind = None
+            else:
+                # see about focused_form.id() in _snapshot_form function
+                focused_form_id = focused_form.id()
+                match message:
+                    case 'before_focused_form_changed':
+                        logger.debug(f'Before focused form changed. Focused form id: {focused_form_id}')
+                        self._snapshot_form(focused_form)
+                    case 'after_focused_form_changed':
+                        logger.debug(f'After forcused form changed. Focused form id: {focused_form_id}')
+                        # it isn't snapshot. It is just setting start position on foucsed form
+                        if not focused_form_id in self._form_snapshots:
+                            for aspect_name, aspect_selector in self._aspect_selectors.items():
+                                if aspect_selector._scroll_listbox.size() == 1:
+                                    aspect_selector._selected_line_ind = 0
+                                else:
+                                    aspect_selector._selected_line_ind = None
+                                self._select_aspect_option(aspect_name)
+                        else:
+                            for aspect_name, aspect_selector in self._aspect_selectors.items():
+                                aspect_selector._selected_line_ind = self._form_snapshots[focused_form_id][aspect_name]
+                                self._select_aspect_option(aspect_name)
+                    # it should be form_delete, but program is too simple
+                    # and it sucks because even after failed reqest, notify sends 'delete'.
+                    # see instruction_building_manager implementation
+                    case 'delete':
+                        del self._form_snapshots[focused_form_id]
+
+        for aspect_name, aspect_selector in self._aspect_selectors.items():
+            aspect_selector.update()
+            self._show_preliminar_info(aspect_name)
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/instruction_form_selector.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/instruction_form_selector.py
new file mode 100644
index 00000000..d83b9f14
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/gui/instruction_form_selector.py
@@ -0,0 +1,113 @@
+# internal
+from ..instruction_building_manager import InstructionBuildingManager
+
+# external
+from core.data_processing.data_management import InstructionForm, Observer
+from core.gui.common_gui import OptionSelector, InfoDisplay
+from core.stages.xml_generation import InstructionXMLBuilder
+import tkinter as tk
+import logging
+
+
+logger = logging.getLogger()
+
+
+class InstructionFormSelector(tk.Frame, Observer):
+    def __init__(self, instruction_manager: InstructionBuildingManager, master=None, cnf={}, **kwargs) -> None:
+        tk.Frame.__init__(self, master, cnf, **kwargs)
+        Observer.__init__(self)
+        self._instruction_manager = instruction_manager
+        self._instruction_manager.attach(self)
+        self.__setup_ui()
+        self.__setup_bindings()
+
+
+    def __setup_ui(self) -> None:
+        self._form_selection_area = tk.Frame(self)
+        self._form_selector = OptionSelector(self._form_selection_area)
+        self._buttons_area = tk.Frame(self._form_selection_area)
+        self._add_button = tk.Button(self._buttons_area, text='add')
+        self._delete_button = tk.Button(self._buttons_area, text='delete')
+        self._form_info = InfoDisplay(self)
+
+        request = {'type': 'get', 'target': 'name'}
+        name = self._instruction_manager.request(request)
+        self._form_selector.set_name(name + ' forms')
+        self._form_info.set_name('Result')
+
+        self._form_selection_area.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        self._form_selector.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self._buttons_area.pack(side=tk.BOTTOM, fill=tk.X)
+        self._add_button.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        self._delete_button.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        self._form_info.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
+
+
+    def __setup_bindings(self) -> None:
+        # i don't know how to make it properly without accessing to the internal object of aspect_selector
+        self._form_selector._scroll_listbox.bind('<Return>', self._select_form, add='+')
+        self._form_selector._scroll_listbox.bind('<Double-Button-1>', self._select_form, add='+')
+        self._form_selector._scroll_listbox.bind('<<Down>>', self._show_preliminar_info, add='+')
+        self._form_selector._scroll_listbox.bind('<<Up>>', self._show_preliminar_info, add='+')
+        self._form_selector._scroll_listbox.bind('<<ListboxSelect>>', self._show_preliminar_info, add='+')
+        self._add_button.config(command=self.add_form)
+        self._delete_button.config(command=self.delete_form)
+
+
+    def _select_form(self, event=None) -> None:
+        selected_line_ind = self._form_selector._selected_line_ind
+        self._instruction_manager.focus_form(selected_line_ind)
+
+
+    def update(self, message=None):
+        if (message is None or
+            message in ['record',
+                        'add',
+                        'delete',
+                        ]
+            ):
+            request = {'type': 'get', 'target': 'form', 'form_ind': 'all'}
+            forms = self._instruction_manager.request(request)
+            if not isinstance(forms, list):
+                raise RuntimeError(f'invalid responce in request {request}; expected an list, not {type(forms)}')
+            self._form_selector.delete(0, tk.END)
+            for form in forms:
+                self._form_selector.insert(tk.END, form)
+            self._form_selector.update()
+            self._show_preliminar_info()
+        elif message == 'after_focused_form_changed':
+            self._show_preliminar_info()
+
+
+    def add_form(self):
+        request = {'type': 'add', 'target': 'form'}
+        self._instruction_manager.request(request)
+
+
+    def delete_form(self, form_ind: int | None = None):
+        if form_ind is None:
+            form_ind = self._form_selector.get_current_ind()
+            if form_ind is None:
+                if self._form_selector._scroll_listbox.size() > 0:
+                    form_ind = self._form_selector._scroll_listbox.size() - 1
+                else:
+                    return
+        request = {'type': 'delete', 'target': 'form', 'form_ind': form_ind}
+        self._instruction_manager.request(request)
+
+
+    def _show_preliminar_info(self, event=None, form_ind: int | None = None):
+        if form_ind is None:
+            form_ind = self._form_selector.get_current_ind()
+            if form_ind is None:
+                self._form_info.clear()
+                self._form_info.insert(tk.END, 'Please, choose instruction form')
+                return
+        request = {'type': 'get', 'target': 'form', 'form_ind': form_ind}
+        instruction_form = self._instruction_manager.request(request)
+        if not isinstance(instruction_form, InstructionForm):
+            logger.error(f'Invalid request {request}; expected an InstructionForm, not {type(instruction_form)}')
+            return
+        instruction_form_str = InstructionXMLBuilder.create_instruction_form_str(instruction_form)
+        self._form_info.clear()
+        self._form_info.insert(tk.END, instruction_form_str)
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_building_manager.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_building_manager.py
new file mode 100644
index 00000000..c7385123
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_building_manager.py
@@ -0,0 +1,63 @@
+# internal
+from .instruction_forms_manager import InstructionFormsManager
+
+# external
+from core.data_processing.ambiguous_data import AmbiguousDict
+from core.data_processing.data_management import InstructionForm, Subject
+from typing import Any
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class InstructionBuildingManager(InstructionFormsManager, Subject):
+    def __init__(self, storage_location: list[InstructionForm], instruction_name: str, instruction_data: AmbiguousDict) -> None:
+        InstructionFormsManager.__init__(self, storage_location, instruction_name, instruction_data)
+        Subject.__init__(self)
+        self.focused_form_ind: int | None = None
+
+
+    # it should me created with reqeuest({'type: 'record', 'target': 'focused_ind', 'value': ind})
+    # but it looks like overkill, so I should think over requests in instrucion_forms_manager
+    def focus_form(self, ind: int | None) -> None:
+        self.notify('before_focused_form_changed')
+        self.focused_form_ind = ind
+        self.notify('after_focused_form_changed')
+
+
+    def is_request_valid(self, request: dict, log=True) -> bool:
+        if ('form_ind' in request and
+            request['form_ind'] == 'focused'
+            ):
+            if self.focused_form_ind is None:
+                if log: logger.debug(f'Request {request} failed; focused form absents')
+                return False
+            else:
+                request['form_ind'] = self.focused_form_ind
+        return super().is_request_valid(request, log)
+
+
+    def request(self, request) -> Any:
+        response = super().request(request)
+        # notify about form-shifitng events
+        match request['type']:
+            case 'record':
+                self.notify('record')
+            case 'add':
+                self.notify('add')
+            case 'delete':
+                self.notify('delete')
+        # changing self.focused_form_ind after deleting
+        if (request['type'] == 'delete' and
+            request['type'] == 'form' and
+            request['form_ind'] == self.focused_form_ind
+            ):
+            if (self.focused_form_ind is not None and
+                self.focused_form_ind >= len(self._forms) # if out of _forms. After 'delete' len = len - 1
+                ):
+                if len(self._forms) > 0:
+                    self.focused_form_ind -= 1
+                else:
+                    self.focused_form_ind = None
+        return response
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_forms_manager.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_forms_manager.py
new file mode 100644
index 00000000..24c3563b
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_analysis/instruction_forms_manager.py
@@ -0,0 +1,310 @@
+from collections.abc import Iterable
+import re
+
+from numpy import isin, require
+from core.data_processing import InstructionForm, DataManager
+from core.data_processing.ambiguous_data import AmbiguousDict
+from core.stages.xml_generation import InstructionXMLBuilder
+from typing import Any
+import copy
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class InstructionParser:
+    def __init__(self, instruction_name: str, instruction_data: AmbiguousDict):
+        self._set_instruction(instruction_name, instruction_data)
+
+
+    def set_instruction(self, instruction_name: str, instruction_data: AmbiguousDict | None = None):
+        if instruction_data is None:
+            instruction_data = self._instruction_data
+        self._set_instruction(instruction_name, instruction_data)
+
+
+    def _set_instruction(self, instruction_name: str, instruction_data: AmbiguousDict):
+        self._instruction_name = instruction_name
+        self._instruction_data = instruction_data
+
+
+    @classmethod
+    def create_empty_form(cls) -> InstructionForm:
+        form = InstructionForm()
+        for aspect_name in InstructionForm.valid_keys:
+            form[aspect_name] = None
+        return form
+
+
+    def get_aspects(self) -> dict:
+        aspects = {}
+        for aspect_name in InstructionForm.valid_keys:
+            aspects[aspect_name] = self.get_aspect_data(aspect_name)
+        return aspects
+
+
+    def get_aspect_data(self, aspect_name: str) -> list:
+        match aspect_name:
+            case 'mnemonic':
+                return self._extract_mnemonics()
+            case 'version':
+                return self._extract_versions()
+            case 'table_data':
+                return self._extract_table_data()
+            case 'chapter_data':
+                return self._extract_chapter_data()
+            case _:
+                logger.error('Incorrect aspect name')
+                return []
+
+
+    def get_name(self) -> str:
+        return self._instruction_name
+
+
+    def _extract_mnemonics(self) -> list:
+        mnemonics_list = list(self._instruction_data['Mnemonics'])
+        mnemonics_list = sorted(mnemonics_list)
+        return mnemonics_list
+
+
+    def _extract_versions(self) -> list:
+        versions = self._instruction_data['Changed versions']
+        versions_list = []
+        if isinstance(versions, Iterable):
+            versions_list = list(versions)
+            versions_list = sorted(versions_list)
+        versions_list.append('All')
+        return versions_list
+
+
+    def _extract_table_data(self) -> list:
+        return list(self._instruction_data['Table'])
+
+
+    def _extract_chapter_data(self) -> list:
+        return list(self._instruction_data['Chapter'])
+
+
+    def is_instruction_ambiguous(self) -> bool:
+        return self._instruction_data.is_ambiguous()
+
+
+
+class InstructionFormsManager(DataManager):
+    # One instruction could have several forms.
+    #
+    # Request looks like {'type': ..., 'target': ..., ...}
+    # There are two mandatory keys: 'type' and 'target'.
+    #
+    # 'type' described in parent class (DataManager).
+    #
+    # Valid 'target' values are in valided_request_keys.
+    # There are two options for target:
+    # 1. Instruction form data ('form')
+    # 2. Aspects data ('aspects')
+    #
+    # Instruciton form data relates to the particular form and its aspects.
+    # Request needs the following:*
+    # 1. 'type': ...
+    # 2. 'target': 'form'
+    # [3]. 'form_ind': any integer within forms list lentgh if type is record, get, delete
+    # [4]. 'aspects' key is needed for record, add and optional for get
+    # 4.1. type is record:
+    #      'aspects': {aspect_name: aspect_data, ...}
+    #      aspects item specifies which aspects of the form to change.
+    # [4.2]. type is get:
+    #        'aspects': [aspect_name, ...]
+    #        aspects item specifies which aspects of the form to get.
+    # 4.3. type is add:
+    #      'aspects': {aspect_name: aspect_data, ...}
+    #      aspects item is optional. It specifies which aspects to change in new form.
+    #
+    # Aspects data relates to the all possible aspects value.
+    # Aspects data is independent of the instruction forms.
+    # Request needs the following:
+    # 1. 'type': 'get' is implemented only for get. I didn't found sencec in other request types
+    # 2. 'target': 'aspects'
+    # 3. 'aspects': [aspect_name, ...]
+    #
+    #*if point in [], it could be optional. Look at [3] in Instruction form request needs
+
+    valid_request_keys = {'type': ('record',
+                                   'get',
+                                   'add',
+                                   'delete',
+                                   ),
+                          'target': ('form',
+                                     'aspects',
+                                     'name', #temp decision
+                                     ),
+                          #there should be 'aspects', but I don't know how to properly add it here
+                          }
+    def __init__(self, storage_location: list[InstructionForm], instruction_name: str, instruction_data: AmbiguousDict) -> None:
+        self._storage_location = storage_location
+        self._instruction_parser = InstructionParser(instruction_name, instruction_data)
+        self._forms: list[InstructionForm] = []
+
+
+    def save(self) -> None:
+        self._storage_location.clear()
+        self._storage_location.extend(self._forms)
+
+
+    def is_request_valid(self, request: dict, log=True) -> bool:
+        if not self._is_request_key_valided(request, 'type', log):
+            return False
+        if not self._is_request_key_valided(request, 'target', log):
+            return False
+        match request['type']:
+            case 'record':
+                if request['target'] == 'form':
+                    if not self._is_key_in_request(request, 'form_ind', log): return False
+                    if not self._is_form_ind_valid(request, log): return False
+                    if not self._is_key_in_request(request, 'aspects', log): return False
+                    if not self._is_aspects_dict_valid(request, log): return False
+                elif request['target'] == 'aspects':
+                    if log: logger.error(f'Invalid request {request}; type:record for target:aspect isn\'t implemented')
+                    return False
+
+            case 'get':
+                if request['target'] == 'form':
+                    if not self._is_key_in_request(request, 'form_ind', log): return False
+                    if not self._is_form_ind_valid(request, log): return False
+                    if self._is_key_in_request(request, 'aspects', False):
+                        if not self._is_aspects_list_valid(request, log): return False
+                elif request['target'] == 'aspects':
+                    if self._is_key_in_request(request, 'aspects', False):
+                        if not self._is_aspects_list_valid(request, log): return False
+
+            case 'add':
+                if request['target'] == 'form':
+                    if self._is_key_in_request(request, 'aspects', False):
+                        if not self._is_aspects_dict_valid(request, log): return False
+                elif request['target'] == 'aspects':
+                    if log: logger.error(f'Invalid request {request}; type:add for target:aspect isn\'t implemented')
+                    return False
+
+            case 'delete':
+                if request['target'] == 'form':
+                    if not self._is_key_in_request(request, 'form_ind', log): return False
+                    if not self._is_form_ind_valid(request, log): return False
+                elif request['target'] == 'aspects':
+                    if log: logger.error(f'Invalid request {request}; type:delete for target:aspect isn\'t implemented')
+                    return False
+        return True
+
+
+    def _is_aspects_list_valid(self, request, log=True) -> bool:
+        if not isinstance(request['aspects'], list):
+            if log: logger.error(f'Invalid request {request}; aspects should be a list')
+            return False
+        valid_keys = set(InstructionForm.valid_keys)
+        wrong_keys = set(request['aspects']) - valid_keys
+        if wrong_keys:
+            if log: logger.error(f'Invalid request {request}; aspects list have unexpected values {wrong_keys}')
+            return False
+        return True
+
+
+    def _is_aspects_dict_valid(self, request, log=True) -> bool:
+        if not isinstance(request['aspects'], dict):
+            if log: logger.error(f'Invalid request {request}; aspects should be a dict')
+            return False
+        valid_keys = set(InstructionForm.valid_keys)
+        wrong_keys = set(request['aspects'].keys()) - valid_keys
+        if wrong_keys:
+            if log: logger.error(f'Invalid request {request}; aspects dict have unexpected keys {wrong_keys}')
+            return False
+        return True
+
+
+    def _is_form_ind_valid(self, request, log=True) -> bool:
+        form_ind = request['form_ind']
+        if form_ind == 'all':
+            return True
+        if not isinstance(form_ind, int):
+            if log: logger.error(f'Invalid request {request}; form_ind should be int or \'all\'')
+            return False
+        if not (0 <= form_ind and form_ind < len(self._forms)):
+            if log: logger.error(f'Invalid request {request}; form_ind out of range')
+            return False
+        return True
+
+
+    def request(self, request: dict) -> Any:
+        if not self.is_request_valid(request):
+            return
+        match request['type']:
+            case 'record':
+                self._record_request(request)
+            case 'get':
+                return self._get_request(request)
+            case 'add':
+                self._add_request(request)
+            case 'delete':
+                self._delete_request(request)
+
+
+    def _record_request(self, request: dict) -> None:
+        if request['target'] == 'form':
+            if request['form_ind'] == 'all':
+                for form in self._forms:
+                    form.update(request['aspects'])
+            else:
+                form = self._forms[request['form_ind']]
+                form.update(request['aspects'])
+
+
+    def _get_request(self, request) -> str | list | dict | InstructionForm:
+        response: str | list | dict | InstructionForm
+        match request['target']:
+            case 'form':
+                if request['form_ind'] == 'all':
+                    response = []
+                    if 'aspects' in request:
+                        for form in self._forms:
+                            form_aspects = {}
+                            for aspect_name in request['aspects']:
+                                form_aspects[aspect_name] = form[aspect_name]
+                            response.append(form_aspects)
+                    else:
+                        response = copy.deepcopy(self._forms)
+                else:
+                    form = self._forms[request['form_ind']]
+                    if 'aspects' in request:
+                        response = {}
+                        for aspect_name in request['aspects']:
+                            response[aspect_name] = form[aspect_name]
+                    else:
+                        response = copy.deepcopy(form)
+            case 'aspects':
+                response = {}
+                if 'aspects' in request:
+                    for aspect_name in request['aspects']:
+                        response[aspect_name] = self._instruction_parser.get_aspect_data(aspect_name)
+                else:
+                    response = copy.deepcopy(self._instruction_parser.get_aspects())
+            case 'name':
+                response = self._instruction_parser.get_name()
+            case _:
+                raise RuntimeError('request validation is wrong: request parsing get unvalid values')
+        return response
+
+
+    def _add_request(self, request) -> None:
+        if request['target'] == 'form':
+            new_form = self._instruction_parser.create_empty_form()
+            if 'aspects' in request:
+                new_form.update(request['aspects'])
+            self._forms.append(new_form)
+
+
+    def _delete_request(self, request) -> None:
+        if request['target'] == 'form':
+            self._forms.pop(request['form_ind'])
+
+
+    def is_instruction_ambiguous(self) -> bool:
+        return self._instruction_parser.is_instruction_ambiguous()
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/__init__.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/__init__.py
new file mode 100644
index 00000000..48520ba7
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/__init__.py
@@ -0,0 +1,2 @@
+from .data_extraction import *
+from .data_extraction_manager import DataManager
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction.py
new file mode 100644
index 00000000..bcf02d3b
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction.py
@@ -0,0 +1,44 @@
+# internal
+from .data_extraction_manager import DataExtractionManager
+
+# external
+from core.stages import Stage, StageGUI, StageTask
+from core.data_processing.data_management import DataManager, Context
+from core.gui import NextButton
+import tkinter as tk
+
+# It has no sence, but I am tired to make it seriously
+class DataExtractionTask(StageTask):
+    def is_completed(self) -> bool:
+        return True
+
+
+class DataExtractionGUI(StageGUI):
+    def __init__(self, data_manager: DataManager, master=None, cnf=..., **kwargs):
+        super().__init__(data_manager, master, cnf, **kwargs)
+        self.__setup_ui()
+
+    def __setup_ui(self):
+        self._label = tk.Label(self, text='Please, vait')
+        self._next_button = NextButton(self, epoint=self, state=tk.DISABLED)
+        self._label.pack(fill=tk.BOTH, expand=True)
+        self._next_button.pack(side=tk.BOTTOM, fill=tk.X)
+
+    def set_completed(self):
+        self._label.config(text='Extraction is completed')
+        self._next_button.config(state=tk.NORMAL)
+
+
+class DataExtraction(Stage):
+    def __init__(self, context: Context, master=None, cnf=..., **kwargs):
+        super().__init__(context, master, cnf, **kwargs)
+        self._data_manager = DataExtractionManager(self._context)
+        self.set_gui(DataExtractionGUI(self._data_manager, master, cnf, **kwargs))
+        self.set_task(DataExtractionTask(self._context))
+
+    def execute(self):
+        super().execute()
+        self._data_manager.request({'type': 'start'})
+        # This error is described in data_markers.py Settingheader.execute()
+        self._gui.set_completed()
+        self.permanently_completed = True
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction_manager.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction_manager.py
new file mode 100644
index 00000000..1ebae97e
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_extraction/data_extraction_manager.py
@@ -0,0 +1,508 @@
+# this code is a complete MESS
+# it needs to be redone
+
+from core.data_processing import AmbiguousList, AmbiguousDict, AmbiguousFrozen, ExtractedInstructionsData, Context, SourceInfo
+
+import pdfplumber
+from pdfplumber.page import Page
+from colorama import Fore, init
+from collections import OrderedDict
+from typing import TypeAlias, Collection, Any
+import os
+import re
+import pickle
+
+from core.data_processing.data_management import DataManager
+
+
+class DataExtractionManager(DataManager):
+    valid_requests = {'type': ('start')}
+    cpu_versions = set(('AVR', 'AVRe', 'AVRe+', 'AVRxm', 'AVRxt', 'AVRrc'))
+
+    def __init__(self, context: Context) -> None:
+        self._context = context
+
+    # Plug for interface implementation
+    # Not all managers needs data for request, so ambiguity of the class should be eliminated
+    def is_request_valid(self, request: dict) -> bool:
+        return True
+
+    def request(self, request) -> Any:
+        if not self.is_request_valid(request):
+            return
+        match request['type']:
+            case 'start':
+                self.__start()
+
+    def __start(self) -> None:
+        pdf_path = self._context[SourceInfo]['pdf_path']
+        dump_dir = 'intermediate_data'
+        os.makedirs(dump_dir, exist_ok=True)
+        tables_data = process_tables_extraction(pdf_path, dump_dir, False)
+        chapter_data = process_chapter_extraction(pdf_path, dump_dir, False)
+        unprocessed_data = merge_instructions_data(tables_data, chapter_data)
+        final_data = process_instructions_data(unprocessed_data)
+
+        extracted_instructions_data = ExtractedInstructionsData()
+        extracted_instructions_data.update(final_data)
+        self._context.record(extracted_instructions_data)
+
+        with open('intermediate_data/avr_instructions_data.txt', 'w') as data_file:
+            for instruction, data in final_data.items():
+                data_file.write(f'{Fore.BLUE}{instruction}{Fore.RESET}: {data}\n')
+
+        with open('intermediate_data/avr_instructions_data.pkl', 'wb') as data_file:
+            pickle.dump(final_data, data_file)
+
+# MESS
+# Unsafe to read
+
+init(autoreset=True)
+
+PartialInstructionsData: TypeAlias = AmbiguousDict[AmbiguousFrozen[str], AmbiguousList]
+RawInstructionsData: TypeAlias = dict[AmbiguousFrozen[str], AmbiguousDict] # naming dead
+ProcessedInstructionsData: TypeAlias = OrderedDict[str, AmbiguousDict]
+TextTable: TypeAlias = list[list[str]]
+
+cpu_versions = DataExtractionManager.cpu_versions
+
+def extract_needed_tables(pdf_path: str, first_page: int, last_page: int) -> list[TextTable]:
+    print(Fore.BLUE + f'[PROCESS]: Starting needed tables extracting from pdf')
+    needed_headers = ['Mnemonic',
+                      'Operands',
+                      'Description',
+                      '# Clocks'] #there are several values
+    tables = []
+    with pdfplumber.open(pdf_path) as pdf:
+        for page in pdf.pages[first_page - 1:last_page]:
+
+            for table in page.extract_tables():
+                headers = table[0]
+
+                 # specific of this datasheet
+                if headers[0] is not None and re.search('continued', headers[0].lower()):
+                    del table[0]
+                    headers = table[0]
+
+                fits = all(
+                    # we use re.search because of #Clocks have several values
+                    any(re.search(needed_header, header) for header in headers if header is not None)
+                    for needed_header in needed_headers
+                )
+                if (fits):
+                    tables.append(table)
+
+    print(Fore.BLUE + f'[PROCESS]: Completes needed tables extracting from pdf')
+    return tables
+
+
+def extract_table_data(table: TextTable) -> PartialInstructionsData:
+    table_data: PartialInstructionsData = AmbiguousDict()
+
+    headers = table[0]
+    try:
+        mnemonic_ind = headers.index('Mnemonic')
+        operands_ind = headers.index('Operands')
+        description_ind = headers.index('Description')
+        clocks_inds = [i for i in range(len(headers)) if "# Clocks" in headers[i]]
+
+    except ValueError as e:
+        raise ValueError(e)
+
+    for row in table[1:]:
+        mnemonic_data = {}
+
+        mnemonic_data['Description'] = row[description_ind]
+
+        mnemonic_data['Operands'] = []
+        for operand in row[operands_ind].split(', '):
+            mnemonic_data['Operands'].append(operand)
+
+        mnemonic_data['Clocks'] = {}
+        for version_ind in clocks_inds:
+            version = headers[version_ind].split('\n')[1]
+            value_search = re.search(r'[^()]+', row[version_ind])
+
+            version_value = None
+            if value_search:
+                version_value = value_search.group(0)
+
+            mnemonic_data['Clocks'][version] = version_value
+
+        mnemonic = AmbiguousFrozen([row[mnemonic_ind]])
+
+        # checking for errors
+        mnemonic_data_error = check_table_row_data(mnemonic_data)
+        if mnemonic_data_error:
+            print(Fore.RED + f'{'-'*8}{mnemonic}{'-'*8}')
+            print(mnemonic_data)
+            for line in mnemonic_data_error:
+                print(line)
+
+        if mnemonic not in table_data:
+            table_data[mnemonic] = AmbiguousList(mnemonic_data)
+        else:
+            table_data[mnemonic].append(mnemonic_data)
+
+    return table_data
+
+def check_table_row_data(table_row_data: dict) -> list[str]:
+    error_message: list[str] = []
+    if not table_row_data:
+        error_message.append(Fore.RED + f'Table row data is empty')
+    else:
+        needed_info = ['Operands',
+                       'Description',
+                       'Clocks',
+                       ]
+        for e in needed_info:
+            if not table_row_data[e]:
+                error_message.append(Fore.RED + f'Table row data has no {e} section')
+
+    return error_message
+
+
+def extract_tables_data(tables: list[TextTable]) -> PartialInstructionsData :
+    data_map: PartialInstructionsData = AmbiguousDict()
+
+    print(Fore.BLUE + f'[PROCESS]: Starting tables data extracting')
+    for table in tables:
+        table_data = extract_table_data(table)
+
+        for key, ambiguous_data in table_data.items():
+            if key not in data_map:
+                data_map[key] = AmbiguousList()
+            data_map[key].extend(ambiguous_data)
+
+    print(Fore.BLUE + f'[PROCESS]: Completes tables data extracting')
+    return data_map
+
+def get_subchapters_pages(pdf_path: str, chapter_number: int, first_page: int, last_page: int, first_subchapter: int = 1) -> list[list[Page]]: # list of subchapters pages
+    subchapters_pages: list[list[Page]] = []
+
+    print(Fore.BLUE + f'[PROCESS]: Starting subchapters pages extracting from pdf')
+
+    with pdfplumber.open(pdf_path) as pdf:
+        page_ind = first_page - 1
+        page = pdf.pages[page_ind]
+        subchapter_number = first_subchapter
+
+        subchapter_regex = fr'{chapter_number}\.{subchapter_number}'
+        next_subchapter_beginning = None
+
+        # find beginning of first subchapter
+        while not next_subchapter_beginning and page_ind < last_page:
+
+            for word in page.extract_words():
+
+                match = re.match(subchapter_regex, word['text'])
+                if match:
+                    next_subchapter_beginning = word['top']
+                    break
+
+            if not next_subchapter_beginning:
+                page_ind += 1
+                page = pdf.pages[page_ind]
+
+        # creating subchapterS_list
+        while page_ind < last_page:
+
+            if not next_subchapter_beginning:
+                raise ValueError('subchapter beginning can\'t be null')
+
+            page = pdf.pages[page_ind]
+            page = page.crop((0, next_subchapter_beginning, page.width, page.height))
+            subchapter_number += 1
+            subchapter_regex = fr'{chapter_number}\.{subchapter_number}'
+            subchapter_pages = []
+            next_subchapter_beginning = None
+
+            # creating subchapter_pages
+            while not next_subchapter_beginning and page_ind < last_page:
+                for word in page.extract_words():
+
+                    match = re.match(subchapter_regex, word['text'])
+
+                    if match:
+                        next_subchapter_beginning = word['top']
+                        crop_bbox = (0, page.bbox[1], page.width, next_subchapter_beginning)
+                        page = page.crop(crop_bbox)
+                        break
+
+                subchapter_pages.append(page)
+
+                if not next_subchapter_beginning:
+                    page_ind += 1
+                    page = pdf.pages[page_ind]
+
+
+            subchapters_pages.append(subchapter_pages)
+
+
+    print(Fore.BLUE + f'[PROCESS]: Completes subchapters pages extracting from pdf')
+    return subchapters_pages
+
+
+def extract_chapter_data(pdf_path: str, chapter_number: int, first_page: int, last_page: int, first_subchapter: int = 1) -> PartialInstructionsData:
+    chapter_data: PartialInstructionsData = AmbiguousDict()
+    subchapters_pages: list[list[Page]] = get_subchapters_pages(pdf_path, chapter_number, first_page, last_page, first_subchapter)
+    roman_numbers_regex = r'\(([iv]+)\)(-\(([iv]+)\))?'
+    status_registers = ['I', 'T', 'H', 'S', 'V', 'N', 'Z', 'C']
+
+    print(Fore.BLUE + f'[PROCESS]: Starting chapter data extracting')
+
+    for subchapter_pages in subchapters_pages:
+        subchapter_data: AmbiguousList[Collection] = AmbiguousList()
+        raw_data: dict[str, AmbiguousList[list]] = {
+            'Opcode': AmbiguousList(),
+            'SREG': AmbiguousList(),
+        }
+        interrupted_flag = False # special for 67 page. Why didn't you make ....continued???
+
+        for page in subchapter_pages:
+            for table in page.extract_tables():
+
+                if any(section is None for row in table for section in row):
+                    continue
+
+                headers = table[0]
+                if headers[0] is not None and re.search('continued', headers[0].lower()): # finding continuation of table
+                    del table[0]
+                    headers = table[0]
+
+                if re.match(roman_numbers_regex, headers[0]):
+                    for i, row in enumerate(table):
+                        roman_match = re.match(roman_numbers_regex, row[0])
+                        if not roman_match:
+                            raise RuntimeError(Fore.RED + f'format error in {i} row, {page.page_number} page')
+
+                        first_roman = roman_to_int(roman_match.group(1))
+                        if roman_match.group(3):
+                            second_roman = roman_to_int(roman_match.group(3))
+                        else:
+                            second_roman = first_roman
+
+                        for i in range(first_roman - 1, second_roman):
+                            raw_data['Opcode'].append(row[1:])
+
+                elif (len(headers) == 4
+                      and all(len(header) == 4 for header in headers)):
+
+                    # if 32-bit opcode
+                    if(len(table) == 2):
+                        headers.extend(table[1])
+                    raw_data['Opcode'].append(headers)
+
+                elif interrupted_flag:
+
+                    raw_data['SREG'].append(headers)
+
+                elif (headers == status_registers):
+
+                    if(len(table) > 1):
+                        raw_data['SREG'].append(table[1])
+                    else:
+                        interrupted_flag = True
+
+        # parse subchapter mnemonic
+        title = subchapter_pages[0].extract_text().split('\n')[0]
+        match_title = re.match(r'^\s*\d+\.\d+\s+([A-Z]+)\s*(\(([^()]+)\))?.*', title)
+
+        if not match_title:
+            raise RuntimeError(f'title is wrong:{title}')
+
+        main_mnemonic: list[str] = [match_title.group(1)]
+        if match_title.group(3):
+            other_mnemonics: list[str] = match_title.group(3).split(', ')
+            main_mnemonic.extend(other_mnemonics)
+        mnemonic = AmbiguousFrozen[str](main_mnemonic)
+
+        # check raw data
+        subchapter_error = check_subchapter_data(raw_data)
+        if subchapter_error:
+            print(Fore.RED + f'{'-'*8}{mnemonic}{'-'*8}')
+            print(raw_data)
+            for line in subchapter_error:
+                print(line)
+
+            if not raw_data['Opcode']: # it should be redone to normal function with user input
+                raw_data['Opcode'] = AmbiguousList(['?'])
+
+        # parse subchapter data
+        if raw_data['SREG'].is_ambiguous():
+            raise RuntimeError(f'chapter {chapter_number}, format error in SREG table: {raw_data['SREG']}')
+
+        for opcode in raw_data['Opcode']:
+            subchapter_data.append({'SREG': raw_data['SREG'], 'Opcode': opcode})
+
+        # adding subchapter data
+        for chapter_key in chapter_data.keys():
+            intersection = chapter_key & mnemonic
+            if (intersection and
+                any(x not in cpu_versions for x in intersection)):
+
+                subchapter_data.extend(chapter_data[chapter_key])
+                mnemonic = mnemonic | chapter_key
+                del chapter_data[chapter_key]
+                break
+
+        chapter_data[mnemonic] = subchapter_data
+
+
+    print(Fore.BLUE + f'[PROCESS]: Completes chapter data extracting')
+    return chapter_data
+
+
+def check_subchapter_data(subchapter_data: dict[str, AmbiguousList[list]]) -> list[str]:
+    error_message: list[str] = []
+    if not subchapter_data:
+        error_message.append(Fore.RED + f'Subchapter data is empty')
+    else:
+        needed_info = ['Opcode',
+                       'SREG',
+                        ]
+        for e in needed_info:
+            if not subchapter_data[e]:
+                error_message.append(Fore.RED + f'Chapter data has no {e} section')
+
+    return error_message
+
+
+def merge_instructions_data(tables_data: PartialInstructionsData, chapter_data: PartialInstructionsData) -> RawInstructionsData:
+    merged_data: RawInstructionsData = RawInstructionsData()
+
+    for mnemonics, data in chapter_data.items():
+        merged_data[mnemonics] = AmbiguousDict()
+        merged_data[mnemonics]['Chapter'] = data
+
+    # key is `AmbiguousFrozen`
+    for mnemonics, data in merged_data.items():
+        # table_key is `AmbiguousFrozen` but has only one element
+        for table_mnemonic, table_data in tables_data.items():
+            if table_mnemonic & mnemonics:
+                if 'Table' in data:
+                    data['Table'].extend(table_data)
+                else:
+                    data['Table'] = table_data
+
+    return merged_data
+
+
+def roman_to_int(roman):
+    if roman is None:
+        return 0
+
+    roman_dict = {
+        'i': 1,
+        'v': 5,
+        'x': 10, # I assume that it is enough.
+    }
+
+    result = 0
+
+    for i in range(len(roman) - 1): # we will add last in the end
+
+        if (roman_dict[roman[i]] >= roman_dict[roman[i + 1]]):
+            result += roman_dict[roman[i]]
+        else:
+            result -= roman_dict[roman[i]]
+
+    result += roman_dict[roman[-1]]
+
+    return result
+
+
+def print_data_map(data_map: dict, mess: str = 'data_map') -> None:
+    print(Fore.BLUE + f'{'-'*8}{mess}{'-'*8}')
+    print(Fore.BLUE + f'size: {len(data_map)}')
+    for key, value in data_map.items():
+        print(f'{key}: {value}')
+
+
+def process_tables_extraction(pdf_path: str, dump_dir: str, reload: bool) -> PartialInstructionsData:
+    tables_data: PartialInstructionsData
+    tables_data_path = dump_dir + '/extracted_tables_data.pkl'
+    if reload or not os.path.exists(tables_data_path):
+        tables_first_page = 17
+        tables_last_page = 22
+        needed_tables = extract_needed_tables(pdf_path, tables_first_page, tables_last_page)
+        tables_data = extract_tables_data(needed_tables)
+        with open(tables_data_path, 'wb') as data_file:
+            pickle.dump(tables_data, data_file)
+    else:
+        with open(tables_data_path, 'rb') as data_file:
+            tables_data = pickle.load(data_file)
+
+    return tables_data
+
+
+def process_chapter_extraction(pdf_path: str, dump_dir: str, reload: bool) -> PartialInstructionsData:
+    chapter_data: PartialInstructionsData
+    chapter_data_path = dump_dir + '/extracted_chapters_data.pkl'
+    if reload or not os.path.exists(chapter_data_path):
+        chapter_first_page = 23
+        chapter_last_page = 146
+        chapter_data = extract_chapter_data(pdf_path, 5, chapter_first_page, chapter_last_page)
+        with open(chapter_data_path, 'wb') as data_file:
+            pickle.dump(chapter_data, data_file)
+    else:
+        with open(chapter_data_path, 'rb') as data_file:
+            chapter_data = pickle.load(data_file)
+
+    return chapter_data
+
+
+def parse_cpu_version(unprocessed_instructions_data: RawInstructionsData):
+    parsed_instructions_data: RawInstructionsData = RawInstructionsData()
+
+    for mnemonics, data in unprocessed_instructions_data.items():
+        mnemonics_cpu_versions = AmbiguousFrozen(mnemonics & cpu_versions)
+        mnemonics_names = AmbiguousFrozen(mnemonics - cpu_versions)
+        if mnemonics_cpu_versions:
+            data['Changed versions'] = mnemonics_cpu_versions
+        else:
+            data['Changed versions'] = AmbiguousList()
+
+        parsed_instructions_data[mnemonics_names] = data
+
+    return parsed_instructions_data
+
+
+def replace_incorrect_xml_characters(unprocessed_instructions_data: RawInstructionsData): # unused
+    incorrect_xml_chars = ('⇔', # it isn't needed
+                            )
+    for instruction_data in unprocessed_instructions_data.values():
+
+        for chapter_data in instruction_data['Chapter']:
+            for sreg in chapter_data['SREG']:
+                for i, sreg_str in enumerate(sreg):
+                    sreg[i] = ''.join(['*' if char in incorrect_xml_chars else char for char in sreg_str])
+
+        for table_data in instruction_data['Table']:
+            instruction_description: str = table_data['Description']
+            table_data['Description'] = instruction_description.replace('\n', ' ')
+
+
+def name_instruction_data(unprocessed_instructions_data: RawInstructionsData) -> ProcessedInstructionsData:
+    named_instructions_data: ProcessedInstructionsData = OrderedDict()
+
+    for mnemonics in unprocessed_instructions_data.keys():
+        sorted_mnemonics = sorted(list(mnemonics))
+        instruction_name = str(sorted_mnemonics[0])
+
+        new_instruction_data = AmbiguousDict() # naming DEAD
+        new_instruction_data['Mnemonics'] = mnemonics
+        new_instruction_data.update(unprocessed_instructions_data[mnemonics])
+
+        named_instructions_data[instruction_name] = new_instruction_data
+
+    named_instructions_data = OrderedDict(sorted(named_instructions_data.items()))
+    return named_instructions_data
+
+
+def process_instructions_data(unprocessed_instructions_data: RawInstructionsData) -> ProcessedInstructionsData:
+    unprocessed_instructions_data = parse_cpu_version(unprocessed_instructions_data)
+    # replace_incorrect_xml_characters(unprocessed_ienstructions_data)
+
+    processed_instruction_data = name_instruction_data(unprocessed_instructions_data)
+    return processed_instruction_data
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/__init__.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/__init__.py
new file mode 100644
index 00000000..8439c7f1
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/__init__.py
@@ -0,0 +1 @@
+from .data_markers import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/data_markers.py b/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/data_markers.py
new file mode 100644
index 00000000..6c89ca3f
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/data_markers/data_markers.py
@@ -0,0 +1,108 @@
+# external
+from core.stages import BidirectionalStage, StageGUI, StageTask
+from core.data_processing import InstructionDataMarkers, Context, DataManager, SourceInfo
+from core.gui import BackNextButtons, PDFRegionSelector
+import tkinter as tk
+
+
+# There should be several Stages related to the data markers with common DataManagaer
+# But in reality I didn't use data markers
+# I decided to create example of using `Stage` (only one: `Settingheader`)
+
+class DataMarkersManager(DataManager):
+    # request is structured like {'type': set_height, 'elements': {...}}
+    # could look like overkill, but check `InstructionFromsManager` in `core/stages/data_analysis`
+    # this class is just a plug for demonstration
+    valid_request_keys = {'type': ('set_height', 'get_height')}
+    expected_elements = {'word', 'line', 'curve'}
+
+    def __init__(self, instruction_data_markers: InstructionDataMarkers) -> None:
+        self._instruction_data_markers = instruction_data_markers
+
+    def is_request_valid(self, request: dict) -> bool:
+        if not self._is_request_key_valided(request, 'type'):
+            return False
+        match request['type']:
+            case 'set_height':
+                return self.expected_elements == request['elements'].keys()
+            case 'get_height':
+                return True
+        return True
+
+    def __get_max_height(self, elements: dict) -> int:
+        # there is 0 because I have no idea about using negative height in pdf
+        max_height = 0
+        for group in elements.values():
+            for e in group:
+                if max_height < e['bottom']:
+                    max_height = e['bottom']
+        return max_height
+
+    def request(self, request: dict) -> None | object:
+        if not self.is_request_valid(request):
+            return
+        match request['type']:
+            case 'set_height':
+                self._instruction_data_markers['header_height'] = self.__get_max_height(request['elements'])
+            case 'get_height':
+                return self._instruction_data_markers['header_height']
+
+
+class SettingHeaderTask(StageTask):
+    def __init__(self, context: Context) -> None:
+        super().__init__(context)
+        # there is IDE error due to the declaraion of get_data
+        # I vould like to point that `get_data(data)` returns `type(data)`, but syntax `f(v) -> g(v): pass` incorrect
+        # This nuance will pop in all `get_data()` calls
+        self._instruction_data_markers: InstructionDataMarkers = self._context[InstructionDataMarkers]
+
+    def is_completed(self) -> bool:
+        header_height = self._instruction_data_markers['header_height']
+        if isinstance(header_height, (int, float)):
+            return True
+        return False
+
+
+class SettingHeaderGUI(StageGUI):
+    def __init__(self, data_manager: DataMarkersManager, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(data_manager, master, cnf, **kwargs)
+        self.__setup_ui()
+        self.__setup_bindings()
+
+    def __setup_ui(self) -> None:
+        self._pdf_region_selector = PDFRegionSelector(self, pdf_selection=True)
+        self._info_label = tk.Label(self, text='Choose an upper bound')
+        self._back_next_buttons = BackNextButtons(self, epoint=self)
+        self._pdf_region_selector.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self._info_label.pack(side=tk.TOP, fill=tk.X)
+        self._back_next_buttons.pack(side=tk.TOP, fill=tk.X)
+
+    def __setup_bindings(self) -> None:
+        self._pdf_region_selector.bind('<<Select>>', self.__on_highlight, add='+')
+
+    def __on_highlight(self, event) -> None:
+        if self._data_manager is None:
+            raise RuntimeError('error in programm logic: expected non None data manager')
+        self._data_manager.request({'type': 'set_height', 'elements': self._pdf_region_selector.get_selected_elements()})
+        height = self._data_manager.request({'type': 'get_height'})
+        self._info_label.configure(text=f'Upper bound height: {height}')
+
+    def set_pdf(self, pdf_path: str) -> None:
+        self._pdf_region_selector.set_pdf(pdf_path)
+
+
+class SettingHeader(BidirectionalStage):
+    def __init__(self, context: Context, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(context, master, cnf, **kwargs)
+        # The same as in `SettingHeaderTask.__init__()`
+        self._data_manager = DataMarkersManager(self._context[InstructionDataMarkers])
+        self.set_gui(SettingHeaderGUI(self._data_manager, master, cnf,**kwargs))
+        self.set_task(SettingHeaderTask(self._context))
+
+    def execute(self) -> None:
+        super().execute()
+        # The same as in `SettingHeaderTask __init__()`
+        pdf_path = self._context[SourceInfo]['pdf_path']
+        # I don't know how to fix warnings '_gui has no set_pdf function
+        # It is raised because _gui is declared as StageGUI type in parent class
+        self._gui.set_pdf(pdf_path)
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/stage.py b/docs_store/opcodes/avr_xml_gen/core/stages/stage.py
new file mode 100644
index 00000000..dababb8f
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/stage.py
@@ -0,0 +1,141 @@
+from abc import ABC, abstractmethod
+import tkinter as tk
+import logging
+from core.data_processing import Context, DataManager
+
+
+logger=logging.getLogger(__name__)
+
+
+class StageGUI(ABC, tk.Frame):
+    def __init__(self, data_manager: DataManager | None=None, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(master, cnf={}, **kwargs)
+        self._kwargs: dict = {}
+        self._cnf: dict = {}
+        self._data_manager = data_manager
+
+    def enable(self, cnf={}, **kwargs) -> None:
+        if kwargs or cnf:
+            self._kwargs = kwargs
+            self._cnf = cnf
+        else:
+            if self._kwargs:
+                kwargs = self._kwargs
+            if self._cnf:
+                cnf = self._cnf
+        self.pack(cnf, **kwargs)
+
+    def pack(self, cnf={}, **kwargs):
+        super().pack(cnf, **kwargs)
+        self._kwargs = kwargs
+        self._cnf = cnf
+
+    def disable(self) -> None:
+        self.pack_forget()
+
+
+class StageTask(ABC):
+    def __init__(self, context: Context) -> None:
+        self._context = context
+
+    @abstractmethod
+    def is_completed(self) -> bool:
+        pass
+
+
+class Stage(ABC):
+    def __init__(self, context: Context, master=None, cnf={}, **kwargs) -> None:
+        self._context = context
+        self._gui: StageGUI | None = None
+        self._task: StageTask | None = None
+        self._next_stage: Stage | None = None
+        self.permanently_completed: bool = False
+
+    def set_task(self, task: StageTask) -> None:
+        self._task = task
+
+    def set_next(self, next_stage: 'Stage | None') -> None:
+        self._next_stage = next_stage
+
+    def set_gui(self, gui: 'StageGUI | None') -> None:
+        self._gui = gui
+        if self._gui is not None:
+            self._gui.bind('<<Complete>>', self.try_complete, add='+')
+
+    def get_next(self) -> 'Stage | None':
+        return self._next_stage
+
+    def execute(self) -> None:
+        if self._gui is not None:
+            self._gui.enable(fill=tk.BOTH, expand=True)
+            self._gui.update()
+
+    def try_complete(self, event=None) -> None:
+        if self._task is None:
+            logger.error(f'Task isn\'t setted')
+            return
+        if not self._task.is_completed():
+            logger.info(f'Can\'t complete stage({self}): task({self._task}) isn\'t completed')
+            return
+        self._complete(event)
+
+    def _complete(self, event=None) -> None:
+        while True:
+            if self._next_stage is None:
+                logger.error('Can\'t execute the next stage due its absence')
+                return
+            elif not self._next_stage.permanently_completed:
+                if self._gui is not None:
+                    self._gui.disable()
+                self._next_stage.execute()
+                return
+            else:
+                self.set_next(self._next_stage.get_next())
+
+
+# there is two direcitons: forward and backward
+# forward is 'complete', backward is 'go_back'
+# naming may seem weird, I commented it in `core.gui.common_ui.BackNextButton`
+class BidirectionalStage(Stage):
+    def __init__(self, context: Context, master=None, cnf={}, **kwargs) -> None:
+        super().__init__(context, master, cnf, **kwargs)
+        self._previous_stage: 'BidirectionalStage | Stage | None' = None
+        self._next_stage: 'BidirectionalStage | Stage | None' = self._next_stage
+
+    def set_gui(self, gui: 'StageGUI | None'):
+        super().set_gui(gui)
+        if self._gui is not None:
+            self._gui.bind('<<GoBack>>', self.try_go_back)
+
+    def set_next(self, next_stage: 'BidirectionalStage | Stage | None') -> None:
+        self._next_stage = next_stage
+
+    def set_previous(self, previous_stage: 'BidirectionalStage | Stage | None') -> None:
+        self._previous_stage = previous_stage
+
+    def get_next(self) -> 'BidirectionalStage | Stage | None':
+        return self._next_stage
+
+    def get_previous(self) -> 'BidirectionalStage | Stage | None':
+        return self._previous_stage
+
+    # In fact I could just make one function instead of two (try_go_back, _go_back)
+    # But I created two functions for the sake of symmetry with try_complete, _complete
+    def try_go_back(self, event=None) -> None:
+        self._go_back(event)
+
+    def _go_back(self, event=None) -> None:
+        while True:
+            if self._previous_stage is None:
+                logger.error(f'Can\'t execute the previous stage due its absence')
+                return
+            elif not self._previous_stage.permanently_completed:
+                if self._gui is not None:
+                    self._gui.disable()
+                self._previous_stage.execute()
+                return
+            elif not isinstance(self._previous_stage, BidirectionalStage):
+                logger.error(f'Previous stage is unreachable')
+                return
+            else:
+                self.set_previous(self._previous_stage.get_previous())
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/__init__.py b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/__init__.py
new file mode 100644
index 00000000..d1b4ed78
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/__init__.py
@@ -0,0 +1,2 @@
+from .xml_generation import *
+from .instruction_xml_builder import *
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/instruction_xml_builder.py b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/instruction_xml_builder.py
new file mode 100644
index 00000000..25e3eccc
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/instruction_xml_builder.py
@@ -0,0 +1,152 @@
+import xml.etree.ElementTree as ET
+import xml.dom.minidom as minidom
+
+from pdfplumber import table
+from core.data_processing import InstructionForm
+
+
+class InstructionXMLBuilder:
+    status_registers = ['I', 'T', 'H', 'S', 'V', 'N', 'Z', 'C']
+
+    @classmethod
+    def create_instruction_xml(cls, instruction_name: str, instruction_forms: list[InstructionForm]) -> ET.Element:
+        root = ET.Element('Instruction')
+        root.set('name', instruction_name)
+
+        for form in instruction_forms:
+            instruction_form = cls.create_instruction_form_xml(form)
+            instruction_form_version = instruction_form.get('value')
+            if instruction_form_version is None:
+                raise RuntimeError(f'form aspect: {form} instruction form version is None')
+            instruction_form_content = instruction_form.find('InstructionForm')
+            if instruction_form_content is None:
+                raise RuntimeError(f'form aspect: {form} instruction form content is None')
+
+            instruction_version = next((version for version in root.findall('Version') if version.get('value') == instruction_form_version), None)
+            if instruction_version is None:
+                instruction_version = ET.SubElement(root, 'Version')
+                instruction_version.set('value', instruction_form_version)
+
+            instruction_version.append(instruction_form_content)
+
+        # sorting mnemonics
+        for version in root:
+            sorted_instruction_forms = sorted(version, key=lambda instruction_form: str(instruction_form.get('mnemonic')))
+            for elem in version.findall('*'):
+                version.remove(elem)
+            version.extend(sorted_instruction_forms)
+
+        # sorting versions
+        sorted_versions = sorted(root, key=lambda version: str(version.get('value')))
+        for version in root.findall('*'):
+            root.remove(version)
+        root.extend(sorted_versions)
+
+        return root
+
+
+    @classmethod
+    def create_instruction_form_xml(cls, form: InstructionForm) -> ET.Element:
+        if not cls.are_instruction_form_aspects_valid(form):
+            raise RuntimeError(f'form aspects not valid: {form}')
+
+        root = ET.Element('Version')
+        version = form['version']
+        if version:
+            root.set('value', version)
+
+        form_et = ET.SubElement(root, 'InstructionForm')
+        mnemonic = form['mnemonic']
+        if mnemonic:
+            form_et.set('mnemonic', mnemonic)
+
+        table_sections = form['table_data']
+        if table_sections:
+            if table_sections['Description']:
+                form_et.set('summary', str(table_sections['Description']))
+
+            if table_sections['Operands']:
+                for operand in table_sections['Operands']:
+                    operand_et = ET.SubElement(form_et, 'Operand')
+                    operand_et.set('type', operand)
+
+            if table_sections['Clocks']:
+                clocks_et = ET.SubElement(form_et, 'Clocks')
+                for key, value in table_sections['Clocks'].items():
+                    clock_et = ET.SubElement(clocks_et, str(key))
+                    clock_et.set('value', value)
+
+        chapter_sections = form['chapter_data']
+        if chapter_sections:
+            if chapter_sections['SREG']:
+                sreg = ET.SubElement(form_et, 'SREG')
+                for i in range(0, len(cls.status_registers)):
+                    flag_et = ET.SubElement(sreg, cls.status_registers[i])
+                    flag_et.set('value', chapter_sections['SREG'][0][i])
+
+            if chapter_sections['Opcode']:
+                encoding_et = ET.SubElement(form_et, 'Encoding')
+                for bits in chapter_sections['Opcode']:
+                    opcode_niddle_et = ET.SubElement(encoding_et, 'Opcode')
+                    opcode_niddle_et.set('nibble', bits)
+
+        return root
+
+
+    @classmethod
+    def are_instruction_form_aspects_valid(cls, form_aspects: dict) -> bool:
+        for aspect_name in InstructionForm.valid_keys:
+            if (aspect_name not in form_aspects.keys()):
+                return False
+
+        return True
+
+
+    @classmethod
+    def are_instruction_form_aspects_filled(cls, form_aspects: dict) -> bool:
+        for aspect_name in InstructionForm.valid_keys:
+            aspect = form_aspects[aspect_name]
+
+            match aspect_name:
+                case 'mnemonic'|'version':
+                    if not isinstance(aspect, str):
+                        return False
+
+                case 'table_data':
+                    aspect_sections = ['Description', 'Operands', 'Clocks']
+                    if (not isinstance(aspect, dict) or
+                        any(section not in aspect.keys() for section in aspect_sections)):
+
+                        return False
+
+                case 'chapter_data':
+                    aspect_sections = ['Opcode', 'SREG']
+                    if (not isinstance(aspect, dict) or
+                        any(section not in aspect.keys() for section in aspect_sections)):
+
+                        return False
+        return True
+
+
+    @classmethod
+    def format_et_to_str(cls, tree: ET.ElementTree) -> str:
+        xml_str = ET.tostring(tree.getroot(), encoding='utf-8', xml_declaration=True).decode('utf-8')
+
+        formatted_xml_str = minidom.parseString(xml_str).toprettyxml(indent="  ")
+        return formatted_xml_str
+
+
+    @classmethod
+    def create_instruction_form_str(cls, form: InstructionForm) -> str:
+        form_el = cls.create_instruction_form_xml(form)
+        form_tree = ET.ElementTree(form_el)
+        form_str = cls.format_et_to_str(form_tree)
+        return form_str
+
+
+    @classmethod
+    def create_instruction_str(cls, name: str, instruction_forms: list[InstructionForm]) -> str:
+        instruction = cls.create_instruction_xml(name, instruction_forms)
+        instruction_tree = ET.ElementTree(instruction)
+        instruction_str = cls.format_et_to_str(instruction_tree)
+        return instruction_str
diff --git a/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/xml_generation.py b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/xml_generation.py
new file mode 100644
index 00000000..55ae591f
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/core/stages/xml_generation/xml_generation.py
@@ -0,0 +1,32 @@
+# internal
+from .instruction_xml_builder import InstructionXMLBuilder
+
+# external
+from core.stages import Stage
+from core.data_processing.data_management import Context, ProcessedInstructionsData
+import xml.etree.ElementTree as ET
+from bs4 import BeautifulSoup
+
+
+class XMLGeneration(Stage):
+    def execute(self) -> None:
+        for name, data in self._context[ProcessedInstructionsData].items():
+            print(f'{name}: {data}')
+        self._build_xml()
+        self.permanently_completed = True
+        self._complete()
+
+
+    def _build_xml(self):
+        instructions_data = self._context[ProcessedInstructionsData]
+        root = ET.Element('InstructionSet')
+        root.set('name', 'AVR')
+        for instruction_name, instruction_forms in instructions_data.items():
+            instruction_xml = InstructionXMLBuilder.create_instruction_xml(instruction_name, instruction_forms)
+            root.append(instruction_xml)
+        tree = ET.ElementTree(root)
+        tree.write('avr_instructions.xml', encoding='utf-8', xml_declaration=True)
+        bs = BeautifulSoup(open('avr_instructions.xml'), 'xml')
+        instructions_xml_str = bs.prettify()
+        with open('avr_instructions.xml', 'w') as file:
+            file.write(instructions_xml_str)
diff --git a/docs_store/opcodes/avr_xml_gen/requirements.txt b/docs_store/opcodes/avr_xml_gen/requirements.txt
new file mode 100644
index 00000000..3d0468b8
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/requirements.txt
@@ -0,0 +1,5 @@
+beautifulsoup4==4.13.3
+colorama==0.4.6
+numpy==2.2.2
+pdfplumber==0.11.4
+Pillow==11.1.0
diff --git a/docs_store/opcodes/avr_xml_gen/test_instruction_forms_manager.py b/docs_store/opcodes/avr_xml_gen/test_instruction_forms_manager.py
new file mode 100644
index 00000000..34c9874f
--- /dev/null
+++ b/docs_store/opcodes/avr_xml_gen/test_instruction_forms_manager.py
@@ -0,0 +1,86 @@
+from core.logging import setup_logging
+setup_logging()
+
+from core.stages.data_analysis import InstructionFormsManager, InstructionParser
+from core.data_processing import ExtractedInstructionsData, AmbiguousDict
+import pickle
+
+data_path = './intermediate_data/avr_instructions_data.pkl'
+instructions_data: ExtractedInstructionsData
+
+with open(data_path, 'rb') as data:
+    instructions_data = pickle.load(data)
+
+storage_location = []
+instruction_name = 'LD'
+instruction_data: AmbiguousDict = instructions_data[instruction_name]
+
+manager = InstructionFormsManager(storage_location, instruction_name, instruction_data)
+
+
+def test_request_validation_with_correct_keys():
+    assert manager.is_request_valid({'type': 'add', 'target': 'form'}) == True
+    assert manager.is_request_valid({'type': 'get', 'target': 'aspects', 'aspects': ['version', 'chapter_data']}) == True
+    # assert manager.is_request_valid({'type': 'record', 'target': 'form', 'aspects': {'mnemonics': None, 'table_data': None}, 'form_ind': 0}) == True
+
+
+def test_request_validation_with_incorrect_keys():
+    assert manager.is_request_valid({'not_type': 'add', 'target': 'form'}) == False
+    assert manager.is_request_valid({'type': 'add', 'not target': 'form'}) == False
+
+
+def test_request_validation_with_missed_keys():
+    assert manager.is_request_valid({'type': 'add'}) == False
+    assert manager.is_request_valid({'target': 'form'}) == False
+    assert manager.is_request_valid({'type': 'delete', 'target': 'form'}) == False
+    # assert manager.is_request_valid({'type': 'record', 'target': 'form', 'form_ind': 0}) == False
+    assert manager.is_request_valid({'type': 'record', 'target': 'form', 'aspects': {'mnemonics': None}}) == False
+
+
+parser = manager._instruction_parser
+
+def test_request_add():
+    forms = manager._forms
+    old_forms_len = len(forms)
+    manager.request({'type': 'add', 'target': 'form'})
+    assert len(forms) == old_forms_len + 1
+    manager.request({'type': 'add', 'target': 'form', 'aspects': {'mnemonic': parser.get_aspect_data('mnemonic')}})
+    assert len(forms) == old_forms_len + 2
+
+    expected_form = InstructionParser.create_empty_form()
+    assert forms[0] == expected_form
+
+    expected_form['mnemonic'] = parser.get_aspect_data('mnemonic')
+    assert forms[1] == expected_form
+
+
+def test_request_delete():
+    forms = manager._forms
+    forms.clear()
+    for i in range(2):
+        forms.append(parser.create_empty_form())
+
+    manager.request({'type': 'delete', 'target': 'form', 'form_ind': 0})
+    assert len(forms) == 1
+    manager.request({'type': 'delete', 'target': 'form', 'form_ind': 0})
+    assert len(forms) == 0
+    manager.request({'type': 'delete', 'target': 'form', 'form_ind': 0})
+    assert len(forms) == 0
+
+
+def test_request_record():
+    if len(manager._forms) < 1:
+        manager._forms.append(parser.create_empty_form())
+    form = manager._forms[0]
+    manager.request({'type': 'record', 'target': 'form', 'form_ind': 0, 'aspects': {'mnemonic': parser.get_aspect_data('mnemonic')}})
+    expected_form = InstructionParser.create_empty_form()
+    expected_form['mnemonic'] = parser.get_aspect_data('mnemonic')
+    assert form == expected_form
+
+
+def test_request_get():
+    if len(manager._forms) < 1:
+        manager._forms.append(parser.create_empty_form())
+    form = manager.request({'type': 'get', 'target': 'form', 'form_ind': 0})
+    expected_form = manager._forms[0]
+    assert form == expected_form