Разработка эмулятора

Разработка эмулятора

Введение

Задачами курсового проектирования по дисциплине «Программирование» являются:

• развитие умения разрабатывать программные модели средней сложности,

• развитие навыков выполнения научно-исследовательских работ в области разработки и стыковки многомодульных программных комплексов;

• развитие навыков работы со стандартами, научно-технической и справочной литературой в области программирования и вычислительной техники; [1, c. 4]

В настоящее время, не смотря на изобилие различного рода языков высокого уровня, все еще находят применение языки ассемблера. В отличие от высокоуровневых языков, где оператору сопоставлено множество машинных кодов, в ассемблерах существует однозначное соответствие между командой и машинным кодом. В этом заключается преимущество низкоуровневых языков программирования. Создавая программу на ассемблере, не обязательно использовать многие модули и дополнительные операции, которые добавляются автоматически в высокоуровневых программах. Это приводит как к уменьшению длины кода, так и к увеличению ее быстродействия. Кроме того, существует возможность решения обратной задачи: перевода машинного кода в программу. Обычно вместе с ассемблерами разрабатываются отладчики. Отладчик позволяет проследить за выполнением программы, вычислительными ресурсами и, при необходимости найти ошибку в коде, либо разобраться в особенностях работы программы на данной ЭВМ.

Данный курсовой проект состоит в разработке пакета программ из ассемблера, отладчика и интерфейса, использующих некоторую систему команд. Конечно, программы не смогут реализовывать всех возможностей современной ЭВМ, но позволят выработать навыки в области алгоритмизации и программирования.

Объем оперативной памяти 2048 байт (8 стр. по 256 байт). Разрядность памяти 11 бит.

Так как работа эмулятора является циклической (за каждый цикл обрабатывается одна команда), то рассмотрим работу процессора за один цикл. Вначале команда выбирается из памяти по адресу, хранящемуся в СЧАК, ее байты заносятся в РК. Затем УУ обрабатывает код команды, заполняет регистры Р1, Р2, А1, А2 и посылает сигналы управления в АЛУ. АЛУ, считая, что операнды для операции расположены в регистрах Р1 и Р2, получает результат и размещает его в регистре А3. Для результата формируются биты признаков (условий) и помещаются в регистр РФ. Затем СЧАК увеличивается на длину команды, либо изменяется искусственно.

1. Постановка задачи

В ходе курсового проекта необходимо разработать программу эмулятора, которая должна имитировать рабочий цикл процессора для каждой команды. При выполнении цикла из памяти читается код команды, адрес которой хранится в счетчике адреса команд (СЧАК). Затем по коду команды определяется количество байтов кода, принадлежащих этой команде, количество и расположение операндов. Процессор читает из памяти операнды исходных данных и выполняет операцию, формирует признаки результата, фиксируя их в регистре флагов (РФ). Далее значение СЧАК увеличивается на длину команды и цикл повторяется сначала, до тех пор, пока не будет обнаружен признак конца команд.

Структура эмулятора должна содержать основные элементы любого процессора: оперативную память, устройство управления (УУ), арифметико-логическое устройство.

Эмулятору необходимо создать массив памяти, который будет заполнен кодами команд и переменными. Каждый элемент массива соответствует ячейке памяти, используемой при выполнении команд. После заполнения памяти отладчик должен выполнить заданные команды, если они будут найдены в таблице команд, представленной ассемблером.

Исходными данными является объектный файл, полученный в результате работы ассемблера. В итоге, отладчик выдает как результат массив памяти и файл протокола, для каждой команды содержащий значения регистров, СЧАК, адрес и значение измененных ячеек памяти. Результатом будет текстовый файл «Result.txt».

2. Анализ структуры микропроцессора

Дана следующая структура процессора (структура 5).

В состав процессора входят:

·        Арифметико-логическое устройство (АЛУ)

·        Регистры АЛУ: регистры операндов Р1 и Р2, регистр флагов (Флаги)

·        Регистры общего назначения: адресные регистры АДРЕС1 (A1) и АДРЕС2 (A2) содержат адреса операндов команд, АДРЕС3 (A3) - адрес результата операции. Эти регистры определяют смещение в диапазоне 0-255 внутри страницы.

·        Счетчик адреса команд (СЧАК)

·        Регистр команд (РК)

·        Шина адреса, шина данных

В состав оперативной памяти входят:

·        Адрес оперативной памяти (АОП)

·        Регистр оперативной памяти (РОП)

·        Собственно ячейки памяти

Объем оперативной памяти 2048 байт (8 стр. по 256 байт). Разрядность памяти имеет 12 битов, но старший бит не используется.

Так как работа эмулятора является циклической (за каждый цикл обрабатывается одна команда), то рассмотрим работу процессора за один цикл. Вначале команда выбирается из памяти по адресу, хранящемуся в СЧАК, ее байты заносятся в РК. Затем УУ обрабатывает данные о команде, заполняет регистры и подает информацию в АЛУ, о необходимости выполнения операции. АЛУ выполняет операцию, результат помещает в память по адресу А3, формирует РФ. Затем СЧАК увеличивается на длину команды, либо изменяется искусственно.

3. Моделирующие переменные

Так как моделируемая ЭВМ содержит три основных устройства: память, УУ, АЛУ-то программа тоже будет содержать три класса. Распишем все моделирующие переменные по классам.

В класс RAM (класс, обозначающий память) будут входить РОП, АОП и собственно память. Оперативную память представим одномерным массивом байтов. Так как заданный объем оперативной памяти 2048 байт, то и размер массива тоже будет 2048. Каждому элементу массива при этом соответствует ячейка памяти, то есть один байт. Уровень доступа ограничим, так как в реальном процессоре мы не можем изменять значения ячеек памяти напрямую.

АОП хранит информацию об адресе ячейки из которой (в которую) читаются (записываются) данные. Так как память состоит из 8 строк в диапазоне 0-255 байт, то АОП будем представлять двухбайтовой переменной (тип short), которая будет содержать номер элемента массива.

РОП хранит данные, содержащиеся в ячейке, из которой читают или записывают данные. Так как в памяти хранятся байты, то и РОП будет иметь тип byte.

В класс ALU будут входить регистры Р1, Р2, Флаги, А1, А2, А3.

Р1 и Р2 - регистры операндов, а значит их тип будет byte.

Адресные регистры указывают на смещение в странице, значит они имеют значения от 0 до 255, для обозначения этого используем тип byte. Создадим массив состоящий из трех элементов (public byte [] A=new byte[3];). A[0] - регистр A1, A[1] - регистр A2, A[2] - регистр A3. Это позволит уменьшить описание команд MOVAi, так как по коду команды будет видно в какой из регистров записать константу.

Регистр флагов обозначим переменной RF типа byte. Данная переменная формирует три признака. Для описания этого понадобится три бита.

-й бит отвечает за равенство результата нулю, 2-ой - за отрицательность результата, 3-ий за арифметическое переполнение. Если результат имеет какой-либо признак, то в этом бите находиться 1, иначе 0.

В класс UU (устройства управления) будут входить СЧАК и РК.

СЧАК представим переменной типа short, так как адрес в массиве памяти задается от 0 до 2047. public short SCHAK=0;

Для регистра команд создадим массив из двух элементов, так как команды могут быть длиной в 1 или 2 байта. В первой ячейке будет храниться первый байт команды, во второй ячейке - второй байт команды.

4. Анализ набора команд

Мнемоника команд моделируемого процессора

Команды имеют длину один или два байта. Биты 0-4 первого байта определяют код команды в соответствии с таблицей команд. Биты 5-7 первого байта задают номер страницы ОП, в которой располагаются данные. Второй байт определяет константу.

Как видно из таблицы команд, все команды делятся на 3 типа:

1.     Команды длиной 1 байт, код + №страницы (показаны желтым и зеленым цветом). Эти команды разобьем на еще на два подтипа

·        Команды первого подтипа (зеленый цвет) выполняют арифметическую или логическую операцию. При прочтении команды этого типа из памяти по адресу, хранящемуся в регистрах А1 и А2, данные копируются в регистры АЛУ Р1 и Р2. Затем выполняется операция и полученный результат записывается в ячейку памяти с номером, хранящимся в А3. После этого устанавливаются регистры флагов и СЧАК увеличивается на 1.

·        Команды второго подтипа (желтый цвет). Эти команды не выполняют ни каких операций, они отвечают за переход по адресу А3. При этом СЧАК принимает значение А3, установка флагов не требуется.

2.   Команды длиной 1 байт, код + 000 (показаны светло-синим цветом)

Эти команды заполняют регистры Р1 и Р2 значениями, содержащимися в А1 и А2. Они также не требуют установки флагов. После их выполнения СЧАК увеличивается на 1.

3. Команды длиной 2 байта, код+000 константа (показаны красным цветом).

Эти команды заполняют адресные регистры А1, А2, А3, записывая в них константу, хранящуюся во втором байте. После выполнения этих команд СЧАК увеличивается на 2.

эмулятор программа процессор цикл

5. Разработка структуры программы: классов и методов

При преобразовании команд из мнемокода ассемблер использует формат «признак-байт». Тогда в каждой паре байтов первый байт может принимать значения: 0 - признак того, что второй байт пары адрес размещения следующих байтов программы, 1-признак того, что второй байт пары - командный байт.

помещает команду, хранящуюся в ячейке памяти под номером, записанным в SCHAK, в нулевой элемент массива RК, с помощью switch определяет по коду команду, каков ее размер, и записывает второй байт команды, для команд второго типа, в первый элемент массива. После этого для команд второго типа заполняются адресные регистры, для команд типа 1А - регистры R1 и R2, затем вызывается соответствующий метод ALU. По окончании метода для команд типа 1А переменная класса RAM memChange получит значение true, для того, чтобы затем знать об изменении в памяти. SCHAK увеличивается на длину команды. Кроме команд указанных в мнемонике данной структуры UU определяет условную команду HALT. Для этой команды не выполняется никаких действий, лишь значение isRunning изменяется на false. После этого данные о регистрах выводятся в файл протокола.

Класс processor будет управлять выполнением программы.

Он будет содержать экземпляры классов RAM, UU, ALU.

В этом классе будет содержаться метод чтения из объектного файла и заполнения памяти, метод обнуления памяти и всех регистров, метод вывода массива памяти, методы для пошагового и полного выполнения программы.

Метод input (чтение) не содержит параметров и возвращаемого значения. Метод будет работать с потоком ввода. Так как входной файл бинарный, то необходимо использовать класс RandomAccessFile. Из исходного файла данные будем посимвольно считывать и записывать в байтовый массив VXfile. Затем, используя этот массив, будем заполнять память. В цикле for от начала до конца VXfile, используя переключатель switch, будем сравнивать значение элемента массива с 0 или 1. Так как использовался формат «признак-байт», то если VХfile[i] будет равно 0, то Vxfile [i+1] и VXfile [i+3] будут являться адресом размещения следующих команд (страница и смещение соответственно). Если же VХfile[i]=1, то следующий байт является командным и будет записан с помощью метода write() класса RAM в память.

Метод makingNull (обнуление памяти) не содержит параметров и возвращаемого значения. Этот метод необходим для обнуления массива памяти и регистров перед выполнением, для наглядности.

Метод out (вывод массива памяти) не содержит параметров и возвращаемого значения. Он работает с потоком вывода в тестовый файл. В цикле for для АОП от 0 до 2047 в файл Result.txt выводится значение РОП. Затем поток вывода закрывается.

Метод makeAll (выполнение всех команд) не содержит параметров и возвращаемого значения. В теле метода будем использовать цикл while. Пока переменная isRunning класса UU имеет значение true, будем выполнять метод steps класса UU.

Метод makeOne (выполнение всех команд) не содержит параметров и возвращаемого значения. В теле метода будем использовать условие, если переменная isRunning класса UU имеет значение true будем выполнять метод steps класса UU.

6. Тестовый пример

Тестовый пример:

Исходный текст программы:

ORG 00H, 00H,05H01H01H, 05H0CH0DH01H01H, 0CH 01H

Текст программы, переведенный в код «признак-байт»:

00 00 00 01 10 01 05 01 81 00 01 00 05 01 00 01 0с 01 01 10 0d 79 01 ff 00 01 00 0с 01 01

Выходные данные отладчика:

5 -127 0 0 0 0 0 0 0 0 0 0 0 0 0… 0 0 0 0

0 0 0 0 0 12 16 13 121 -1 0 1 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

Выполнена команда MOVA3 5

А1 0

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 2

Выполнена команда JMP 1

А1 0

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 105

Выполнена команда MOVA1 c

А1 c

А2 0

А3 5

Р1 0

Р2 0

РФ 0

СЧАК 107

Выполнена команда MOVA3 d

А1 c

А2 0

А3 d

Р1 0

Р2 0

РФ 0

СЧАК 109

Выполнена команда NOT 1

А1 c

А2 0

А3 d

Р1 1

Р2 0

РФ 6

СЧАК 10a

Записанo АОП = 10d

РОП = fe

Выполнена команда HALT

5 -127 0 0 0 0 0 0 0 0 0 0 0 0 0… 0 0 0 0

0 0 0 0 0 12 16 13 121 -1 0 1 -2 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0

Заключение

В ходе выполнения курсовой работы создана программная модель кросс-отладчика. Данная программа имитирующую рабочий цикл процессора и выводит данные о пошаговом выполнении команд. Для наглядности, а также для связи с интерфейсом, программа выводит результаты выполнения команд в отдельный файл. Благодаря чему, можно детально рассмотреть рабочий цикл процессора. Данная работа помогает понять, как же работает микропроцессор, какие операции выполняет, какими командами на него влияют, что происходит под влиянием этих команд. А также не только улучшить навыки программирования, но и применять всевозможные алгоритмы.

Библиографический список

1.   П. Ноутон, Г. Шилдт Java 2: The Complete Reference. - Издательство «БХВ-Петербург», 2007, 1072 с. Jennifer Golden, Java Programming Language, 2002

2.       N. Cravotta «Real-time operating systems», Embedded system programming, 1997/march

Приложение

public class RAM {static byte[] R=new byte[2048];static short AOP=0;static byte ROP=0;static boolean memChange;void read() {=R[AOP];

}void write() {[AOP]=ROP;

}

}class ALU {byte R1=0;byte R2=0;byte RF=0;byte [] A=new byte[3];byte rez=0;RAM ram=new RAM();

// public ALU() {

// byte R1=0;

// byte R2=0;

// byte RF=0;}short address (byte p, byte s) {ad=0;=(short) (p*256+s);ad;}void setFlags (int s)

{RF=0;(s==0) RF|=1; else RF&=(byte) 0xFE;(s<0) RF|=2; else RF&=(byte) 0xFD;((s>127)||(s<-128)) RF|=4; else RF&=(byte) 0xFB;

}void doADD (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1+R2);.write();(R1+R2);

}void doADC (byte page) {.AOP=address (page, A[2]);(R1+R2);.ROP=(byte) (R1+R2+RF&0x04);.write();

}void doSBB (byte page) {.AOP=address (page, A[2]);(R1-R2);.ROP=(byte) (R1-R2-RF&0x04);.write();

}void doMUL (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1*R2);.write();(R1*R2);

}void doDIV (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1/R2);.write();(R1/R2);

}void doMOD (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1% R2);.write();(R1% R2);

}void doABS (byte page) {.AOP=address (page, A[2]);.ROP=(byte) ((R1|0xfe)&0x7f);.write();(java.lang. Math.abs(R1));

}void doAND (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1&R2);.write();(R1&R2);

}void doOR (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1|R2);.write();(R1|R2);

}void doXOR (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (R1^R2);.write();(R1^R2);

}void doNOT (byte page) {.AOP=address (page, A[2]);.ROP=(byte) (~R1|0x01);.write();(~R1);

}void doMOVS (byte page) {.AOP=address (page, A[2]);.ROP=R1;.write();

}void doCMPS() {(R1-R2);

}

}java.io.*;java.lang.*;java.lang. Byte.*;java.lang. String.*;class UU {short SCHAK=0;byte[] RK=new byte[2];RAM ram=new RAM();ALU alu=new ALU();boolean isRunning=true;out;void steps() throws IOException {

// FileWriter out=new FileWriter («Result.txt», true);=new PrintWriter («Result.txt»);name=null;j=0;page=0;{ram.AOP=SCHAK;.read();[0]=(byte) (ram.ROP);=(byte) (RK[0]&0x07);((RK[0]&0xff)>>>3) {0x00:0x01:0x02: {name= «MOVA»+((RK[0]>>>3)+1)+»»;.AOP=(short) (SCHAK+1);.read();f=ram.ROP;[1]=ram.ROP;+=Integer.toHexString (RK[1]);.A [RK[0]>>>3]=RK[1];.memChange=false;+=2;;}0x04: {= «ADD»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doADD(page);+=1;.memChange=true;;}0x05: {= «ADC»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doADC(page);++;.memChange=true;;}0x06: {= «SUB»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doSUB(page);++;.memChange=true;;}0x07: {= «SBB»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doSBB(page);++;.memChange=true;;}0x08: {= «MUL»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doMUL(page);++;.memChange=true;;}0x09: {= «DIV»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doDIV(page);++;.memChange=true;;}0x0a: {= «MOD»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doMOD(page);++;.memChange=true;;}0x0b: {= «ABS»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doABS(page);++;.memChange=true;;}0x0c: {= «AND»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doAND(page);++;.memChange=true;;}0x0d: {= «OR»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doOR(page);++;.memChange=true;;}0x0e: {= «XOR»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doXOR(page);++;.memChange=true;;}0x0f: {= «NOT»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[1]);.read();.R2=ram.ROP;.doNOT(page);++;.memChange=true;;}0x10: {= «JMP»+» «+Integer.toHexString(page);.memChange=false;m=alu.A[2];d=alu.address (page, m);=d;;}0x11: {= «JB»+» «+Integer.toHexString(page);.memChange=false;(alu.RF<0) SCHAK=alu.address (page, alu.A[2]);SCHAK++; break;}0x12: {= «JNZ»+» «+Integer.toHexString(page);.memChange=false;(alu.RF!=0) SCHAK=alu.address (page, alu.A[2]);SCHAK++; break;}0x14: {= «MOVS»+» «+Integer.toHexString(page);.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.memChange=true;.doMOVS(page);++; break;}0x15: {= «CMPS»+» «+Integer.toHexString(page);.memChange=false;.AOP=alu.address (page, alu.A[0]);.read();.R1=ram.ROP;.AOP=alu.address (page, alu.A[2]);.read();.R2=ram.ROP;.doCMPS();++; break;}(byte) 0x1f: {name= «HALT»; isRunning=false; break;}

}

System.out.println («выполнена команда «+name);

out.print (name+»»);(name!= «HALT») {.out.println («А1 «+Integer.toHexString (alu.A[0]));.out.println («А2 «+Integer.toHexString (alu.A[1]));.out.println («А3 «+Integer.toHexString (alu.A[2]));.out.println («Р1 «+Integer.toHexString (alu.R1));.out.println («Р2 «+Integer.toHexString (alu.R2));.out.println («РФ «+Integer.toHexString (alu.RF));.out.println («РK «+Integer.toHexString (RK[0])+»»);(name== «MOVA»+((RK[0]>>>3)+1)+»») System.out.println (Integer.toHexString (RK[1]));.out.println («СЧАК «+Integer.toHexString(SCHAK));(name== «MOVA»+((RK[0]>>>3)+1)+»») out.print (Integer.toHexString (RK[1]));(ram.memChange) {.out.println («Записана переменная АОП = «+Integer.toHexString (ram.AOP));.out.println («РОП = «+Integer.toHexString (ram.ROP));.print (Integer.toHexString (ram.AOP)+»»);.print (Integer.toHexString (ram.ROP)+»»);

}.println (Integer.toHexString(SCHAK));

}.out.println();.R1=0;.R2=0;[1]=0;}{ //out.close();

}

}

}java.io.*;java.lang.*;java.lang. Byte.*;java.lang. String.*;class Processor {RAM ram=new RAM();ALU alu=new ALU();UU uu=new UU();byte[] VXfile;out;void input() throws IOException {

// out=new FileWriter («Result.txt»);d;toRead;in=null;x=0, i=0; long m=0;{in=new RandomAccessFile («121.jar», «r»);=in.length();=in.length();=new byte[(int) m];(toRead>0) {=in.readByte();=1;[i]=d;++;

}

}(Exception e) {System.out.println(e);}{(in==null) {in.close();}

}j=0; int k=0;.SCHAK=alu.address (VXfile[1], VXfile[3]);(i=0; i<VXfile.length-2; i+=2)(VXfile[i]) {0: {byte p=VXfile [i+1], s=VXfile [i+3];.AOP=alu.address (p, s);+=2;;}1: {ram.ROP=VXfile [i+1];.write();.AOP++;;}}

}void out() throws IOException {

// out=new FileWriter («Result.txt», true);=new PrintWriter («Result.txt»);{for (ram.AOP=0; ram.AOP<2048; ram.AOP++)((ram.AOP+1)%256!=0) {ram.read(); System.out.print (ram.ROP+»»);}System.out.println();.out.println();(ram.AOP=0; ram.AOP<2048; ram.AOP++)((ram.AOP+1)%256!=0) {ram.read(); out.print (ram.ROP+»»);}out.println();.println();}{ //out.close();

}

}void makingNull() {(ram.AOP=0; ram.AOP<2048; ram.AOP++)

{ram.ROP=0;.write();}.SCHAK=0;.RK[0]=0;.RK[1]=0;.RF=0;.A[0]=0;.A[1]=0;.A[2]=0;

}void makeAll() throws IOException {(uu.isRunning).steps();

}void makeOne() throws IOException {(uu.isRunning==true).steps();}

}