“AGC_128_document is a living archive of the standard — a unified structure collecting text, ASCII, DNA blocks, and technical artifacts. The repository preserves the etalon formats and rituals, ensuring stability, traceability, and readiness for future versions and expansions.”
# AGC_128_v.1 — Adaptive Genetic Code 128
### Official README (First Recorded Chat Edition)
## Authors
- **Aleksandar Kitipov**
Emails: aeksandar.kitipov@gmail.com / aeksandar.kitipov@outlook.com
- **Copilot**
Co‑author, technical collaborator, documentation support
---
## Overview
AGC_128_v.1 is a lightweight, fully reversible, DNA‑inspired text encoding system.
It converts any ASCII text into a stable A/T/G/C genetic sequence and can decode it back **1:1 without loss**.
The entire encoder/decoder is approximately **15 KB**, requires **no external libraries**, and runs instantly even on older 32‑bit machines.
This README is based on the very first conversation where AGC‑128 was conceived, tested, and formalized.
---
## What the Program Does
AGC_128_v.1 performs a complete reversible transformation:
Text → ASCII → Binary → Genetic Bits → A/T/G/C DNA Sequence
and back:
DNA Sequence → Genetic Bits → Binary → ASCII → Text
The system preserves:
- letters
- numbers
- punctuation
- whitespace
- ASCII extended symbols
- structured blocks
- FASTA‑formatted sequences
If you encode text and decode it again, the output will match the original **exactly**, character‑for‑character.
---
## Key Features
### 1. Fully Reversible Encoding
Every ASCII character becomes a 4‑gene sequence.
Decoding restores the exact original text with zero corruption.
### 2. Self‑Checking Genetic Structure
AGC‑128 uses three internal biological‑style integrity rules:
#### **Sum‑2 Rule**
Each 2‑bit gene has a total bit‑sum of 2.
Any bit flip breaks the rule and becomes detectable.
#### **No‑Triple Rule**
The sequence can never contain `111` or `000`.
If such a pattern appears, the data is invalid.
#### **Deterministic‑Next‑Bit Rule**
- After `11` → the next bit must be `0`
- After `00` → the next bit must be `1`
This allows partial reconstruction of missing or damaged data.
Together, these rules make AGC‑128 extremely stable and self‑verifying.
---
## Genetic Alphabet
AGC‑128 uses four genetic symbols mapped from 2‑bit pairs:
11 → G
00 → C
10 → A
01 → T
Every ASCII character (8 bits) becomes four genetic symbols.
---
## FASTA Compatibility
The DNA output can be saved as a `.fasta` file and later decoded back into text.
This makes AGC‑128 suitable for:
- digital archiving
- DNA‑like storage experiments
- long‑term data preservation
- bioinformatics‑style workflows
---
## Why It Works So Well
AGC‑128 is powerful because the **structure itself** enforces stability.
No heavy algorithms, no compression, no GPU, no dependencies.
It is inspired by biological DNA:
- small alphabet
- simple rules
- strong internal consistency
- natural error detection
- predictable rhythm
This allows the entire system to remain tiny (≈15 KB) yet extremely robust.
---
## Example
### Input:
Hello!
### Encoded DNA:
T C G A T C G A T C G G T C G G T C A A C C A G
### Decoded Back:
Hello!
Perfect 1:1 recovery.
---
## Project Status
- **AGC_128_v.1** — stable core
- **AGC_128_v.2 (planned)** — Unicode, Cyrillic, binary files, metadata, extended genome logic
---
## Notes
This README represents the **first official documentation** of AGC‑128, created directly from the original chat where the concept was born, tested, and refined.
import tkinter as tk from tkinter import filedialog, simpledialog, messagebox
current_encoded_nucleotide_sequence = []
nuc_to_int = { ‘C’: 0, ‘T’: 1, ‘A’: 2, ‘G’: 3 } int_to_nuc = {v: k for k, v in nuc_to_int.items()}
def string_to_nucleotide_sequence(text): “”” Всеки символ -> ASCII (8 бита) -> 4 двойки бита -> 4 нуклеотида. “”” seq = [] for ch in text: ascii_val = ord(ch) # Extract 2-bit chunks b1 = (ascii_val » 6) & 0b11 # Most significant 2 bits b2 = (ascii_val » 4) & 0b11 b3 = (ascii_val » 2) & 0b11 b4 = ascii_val & 0b11 # Least significant 2 bits seq.extend([int_to_nuc[b1], int_to_nuc[b2], int_to_nuc[b3], int_to_nuc[b4]]) return seq
def calculate_genetic_checksum(nucleotide_sequence): “”” Calculates a genetic checksum for a given nucleotide sequence. The checksum is based on the sum of 2-bit integer representations of nucleotides, modulo 16, encoded as two nucleotides. This uses the previously working logic (total_sum % 16). “”” total_sum = 0 for nuc in nucleotide_sequence: total_sum += nuc_to_int.get(nuc, 0) # Use .get with default 0 for safety
checksum_value = total_sum % 16 # Checksum is a value between 0 and 15 (4-bit value)
# Convert checksum value to 4-bit binary string (e.g., 0 -> "0000", 15 -> "1111")
checksum_binary = f"{checksum_value:04b}"
# Convert 4-bit binary string to two nucleotides using int_to_nuc
checksum_nuc1_int = int(checksum_binary[0:2], 2) # Convert "00" to 0, "01" to 1, etc.
checksum_nuc2_int = int(checksum_binary[2:4], 2)
checksum_nuc1 = int_to_nuc[checksum_nuc1_int]
checksum_nuc2 = int_to_nuc[checksum_nuc2_int]
return [checksum_nuc1, checksum_nuc2]
def add_genetic_checksum(seq): “”” Appends the calculated genetic checksum to a copy of the original nucleotide sequence. “”” checksum = calculate_genetic_checksum(seq) sequence_with_checksum = list(seq) # Create a copy sequence_with_checksum.extend(checksum) return sequence_with_checksum
def verify_genetic_checksum(seq): “”” Verifies the genetic checksum of a sequence. Assumes the last two nucleotides are the checksum. “”” if len(seq) < 2: return False data = seq[:-2] # The original data part checksum = seq[-2:] # The provided checksum part expected = calculate_genetic_checksum(data) return checksum == expected
def decode_nucleotide_sequence_to_string(nucleotide_sequence): “”” 4 нуклеотида -> 4x2 бита -> 8-битов ASCII. “”” decoded_chars = [] for i in range(0, len(nucleotide_sequence), 4): chunk = nucleotide_sequence[i:i+4] if len(chunk) != 4: # Warning already handled in GUI if length mismatch break
# Convert each nucleotide to its 2-bit integer representation
b1 = nuc_to_int[chunk[0]]
b2 = nuc_to_int[chunk[1]]
b3 = nuc_to_int[chunk[2]]
b4 = nuc_to_int[chunk[3]]
# Combine the four 2-bit integers to form a single 8-bit integer
ascii_val = (b1 << 6) | (b2 << 4) | (b3 << 2) | b4
decoded_chars.append(chr(ascii_val))
return "".join(decoded_chars)
def generate_fasta_string(seq, header, line_width=60): out_lines = [f”>{header}”] for i in range(0, len(seq), line_width): out_lines.append(““.join(seq[i:i+line_width])) return “\n”.join(out_lines) + “\n”
def visualize_nucleotide_sequence(seq, title=”AGC-128 Sequence”, checksum_length=0, error_index=-1):
“””
Плейсхолдър – няма графика, само показва информация.
“””
info_message = f”Title: {title}\n”
info_message += f”Sequence Length: {len(seq)} nucleotides\n”
if checksum_length > 0:
info_message += f”Checksum Length: {checksum_length} nucleotides\n”
info_message += f”Checksum Nucleotides: {‘ ‘.join(seq[-checksum_length:])}\n”
if error_index != -1:
info_message += f”Highlighted Error at index: {error_index} (nucleotide: {seq[error_index]})\n”
info_message += “\n(Visualization functionality is a placeholder in this Colab environment. “
“Run locally for full matplotlib visualization.)”
messagebox.showinfo(
"Visualize Sequence (Placeholder)",
info_message
)
def setup_gui(): global current_encoded_nucleotide_sequence
root = tk.Tk()
root.title("AGC-128 Notepad")
text_widget = tk.Text(root, wrap='word')
text_widget.pack(expand=True, fill='both')
menubar = tk.Menu(root)
root.config(menu=menubar)
# ---------- FILE ----------
file_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label="File", menu=file_menu)
def open_file():
global current_encoded_nucleotide_sequence
file_path = filedialog.askopenfilename(
filetypes=[("Text files", "*.txt"), ("All files", "*.* затем")]
)
if file_path:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, content)
current_encoded_nucleotide_sequence.clear()
def save_file():
file_path = filedialog.asksaveasfilename(
defaultextension=".txt",
filetypes=[("Text files", "*.txt"), ("All files", "*.* затем")]
)
if file_path:
content = text_widget.get("1.0", tk.END)
with open(file_path, 'w', encoding='utf-8') as file:
file.write(content)
file_menu.add_command(label="Open", command=open_file)
file_menu.add_command(label="Save", command=save_file)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=root.quit)
# ---------- ENCODE ----------
encode_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label="Encode", menu=encode_menu)
def encode_to_fasta_action():
global current_encoded_nucleotide_sequence
input_text = text_widget.get("1.0", tk.END).strip()
if not input_text:
messagebox.showwarning("No Input", "Please enter text to encode in the editor.")
return
fasta_id = simpledialog.askstring("FASTA Identifier", "Enter FASTA header ID:")
if not fasta_id:
messagebox.showwarning("Missing ID", "FASTA identifier cannot be empty.")
return
add_checksum = messagebox.askyesno("Checksum Option", "Do you want to add a genetic checksum?")
try:
nucleotide_sequence_temp = string_to_nucleotide_sequence(input_text)
if add_checksum:
processed_sequence = add_genetic_checksum(nucleotide_sequence_temp)
else:
processed_sequence = nucleotide_sequence_temp
current_encoded_nucleotide_sequence[:] = processed_sequence
fasta_output = generate_fasta_string(
processed_sequence,
fasta_id,
line_width=60
)
save_path = filedialog.asksaveasfilename(
defaultextension=".fasta",
filetypes=[("FASTA files", "*.fasta"), ("All files", "*.* затем")],
title="Save Encoded FASTA As"
)
if save_path:
with open(save_path, 'w', encoding='utf-8') as f:
f.write(fasta_output)
messagebox.showinfo("Success", f"FASTA encoded and saved to {save_path}")
else:
messagebox.showinfo("Cancelled", "FASTA save operation cancelled.")
except Exception as e:
messagebox.showerror("Encoding Error", f"An error occurred during encoding: {e}")
encode_menu.add_command(label="Encode to AGC-128 FASTA", command=encode_to_fasta_action)
# ---------- DECODE ----------
decode_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label="Decode", menu=decode_menu)
def load_and_decode_fasta_action():
global current_encoded_nucleotide_sequence
file_path = filedialog.askopenfilename(
filetypes=[("FASTA files", "*.fasta"), ("All files", "*.* затем")]
)
if not file_path:
messagebox.showinfo("Cancelled", "FASTA load operation cancelled.")
return
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
lines = content.splitlines()
if not lines or not lines[0].startswith('>'):
messagebox.showwarning(
"Invalid FASTA",
"Selected file does not appear to be a valid FASTA format (missing header)."
)
return
# Extract sequence, ignore header(s), keep only A/T/G/C
seq_raw = "".join(line.strip() for line in lines[1:] if not line.startswith(">"))
valid = {'A', 'T', 'G', 'C'}
extracted_nucs_list = [c for c in seq_raw if c in valid]
if not extracted_nucs_list:
messagebox.showwarning("Empty Sequence", "No nucleotide sequence found in the FASTA file.")
return
current_encoded_nucleotide_sequence[:] = extracted_nucs_list
sequence_to_decode = extracted_nucs_list
checksum_info = ""
# Check for checksum based on length: if length % 4 == 2, it indicates a 2-nucleotide checksum
if len(extracted_nucs_list) >= 2 and len(extracted_nucs_list) % 4 == 2:
ask_checksum = messagebox.askyesno(
"Checksum Detected?",
"The sequence length suggests a 2-nucleotide checksum.\n"
"Do you want to verify and remove it before decoding?"
)
if ask_checksum:
is_valid_checksum = verify_genetic_checksum(extracted_nucs_list)
checksum_info = f"\nChecksum valid: {is_valid_checksum}"
if is_valid_checksum:
messagebox.showinfo("Checksum Status", f"Checksum is valid!{checksum_info}")
else:
messagebox.showwarning(
"Checksum Status",
f"Checksum is INVALID! Data may be corrupted.{checksum_info}"
)
sequence_to_decode = extracted_nucs_list[:-2] # Remove checksum for decoding
elif len(extracted_nucs_list) % 4 != 0:
messagebox.showwarning(
"Sequence Length Mismatch",
"The nucleotide sequence length is not a multiple of 4, nor does it suggest a 2-nucleotide checksum.\n"
"Decoding might result in an incomplete last character."
)
decoded_text = decode_nucleotide_sequence_to_string(sequence_to_decode)
text_widget.delete("1.0", tk.END)
text_widget.insert(tk.END, decoded_text)
messagebox.showinfo("Decoding Success", f"FASTA file successfully loaded and decoded!{checksum_info}")
except Exception as e:
messagebox.showerror("Decoding Error", f"An error occurred during FASTA loading or decoding: {e}")
decode_menu.add_command(label="Load and Decode AGC-128 FASTA", command=load_and_decode_fasta_action)
# ---------- TOOLS ----------
tools_menu = tk.Menu(menubar, tearoff=0)
menubar.add_cascade(label="Tools", menu=tools_menu)
def verify_checksum_action():
global current_encoded_nucleotide_sequence
if not current_encoded_nucleotide_sequence:
messagebox.showwarning("No Sequence", "No encoded nucleotide sequence is currently loaded or generated.")
return
if len(current_encoded_nucleotide_sequence) >= 2 and len(current_encoded_nucleotide_sequence) % 4 == 2:
is_valid = verify_genetic_checksum(current_encoded_nucleotide_sequence)
messagebox.showinfo("Checksum Verification", f"Checksum valid: {is_valid}")
else:
messagebox.showwarning(
"No Checksum Detected",
"The current sequence length does not suggest a 2-nucleotide checksum.\n"\
"Checksum verification requires the sequence to be 'data + 2 checksum nucleotides'."
)
def visualize_action():
global current_encoded_nucleotide_sequence
if not current_encoded_nucleotide_sequence:
messagebox.showwarning(
"No Sequence",
"No encoded nucleotide sequence is currently loaded or generated to visualize."
)
return
checksum_len = 0
if len(current_encoded_nucleotide_sequence) >= 2 and len(current_encoded_nucleotide_sequence) % 4 == 2:
checksum_len = 2
try:
visualize_nucleotide_sequence(
current_encoded_nucleotide_sequence,
"Current AGC-128 Sequence",
checksum_length=checksum_len
)
except Exception as e:
messagebox.showerror("Visualization Error", f"An error occurred during visualization: {e}")
tools_menu.add_command(label="Verify Checksum", command=verify_checksum_action)
tools_menu.add_command(label="Visualize Sequence", command=visualize_action)
root.mainloop()
if name == “main”: try: setup_gui() except tk.TclError as e: print(f”Error: {e}”) print(“Tkinter GUI cannot be displayed in this environment (e.g., Google Colab).”) print(“Run this script locally on your computer with a graphical interface.”)
Test> This is a sample text created specifically for testing a custom text editor that can encode and decode text in different formats. The main goal of this paragraph is to verify that the editor correctly preserves all characters, including letters, numbers, punctuation, whitespace, and special symbols. If the encoded version of this text can be successfully decoded back to this exact content, without any missing or changed characters, then the core logic of the editor is working correctly. You can also use this text to test copy, paste, undo, redo, and any other features you have implemented in your application.
Below this paragraph, you will find a long sequence of ASCII characters and extended symbols that you can use for more advanced testing. Make sure that your editor handles every single one of them without corruption, truncation, or unintended modifications.
ASCII / extended characters test block:
!”#
%^&()_+-=[]{};’:”,.<>/?|
000111222333444555666777888999
AAAaaaBBBbbbCCCcccDDDdddEEEeeeFFFfff
~~!!@@##$$%%^^&&*(())++–==//
| || ||| |||| ||||| |||||
END-OF-LINE-TEST–>__<–END-OF-LINE-TEST
[TEST-BLOCK-START]
Test_123-ABC-xyz-999
Code: X1Y2-Z3W4-TEST-0001
Path-like /folder/subfolder/file.txt
Email-like test@example.com
URL-like https://example.com/test?param=1&other=2
Tabs and spaces mixed together
[TEST-BLOCK-END]
Test TTTCTAACTAATTGCGCACCTAATTGCGCACCTACTCACCTGCGTACTTAGTTGCCTAGC TATTCACCTGTCTATTTGACTGTCCACCTACGTGCATATTTACTTGTCTATTTATCCACC TGCGTGCCTATTTACGTAATTATATAATTACGTACTTAGCTAGCTGATCACCTATATAGG TGCACACCTGTCTATTTGCGTGTCTAATTAGATATGCACCTACTCACCTACGTGTTTGCG TGTCTAGGTAGTCACCTGTCTATTTGACTGTCCACCTATTTATCTAATTGTCTAGGTGCA CACCTGTCTAACTACTTGTCCACCTACGTACTTAGACACCTATTTAGATACGTAGGTATC TATTCACCTACTTAGATATCCACCTATCTATTTACGTAGGTATCTATTCACCTGTCTATT TGACTGTCCACCTAATTAGACACCTATCTAATTATATATATATTTGCATATTTAGATGTC CACCTATATAGGTGCATAGTTACTTGTCTGCGCAGACACCTTTCTAACTATTCACCTAGT TACTTAATTAGACACCTATGTAGGTACTTAGCCACCTAGGTATACACCTGTCTAACTAAT TGCGCACCTGCCTACTTGCATACTTATGTGCATACTTGCCTAACCACCTAATTGCGCACC TGTCTAGGCACCTGTATATTTGCATAATTATATGATCACCTGTCTAACTACTTGTCCACC TGTCTAACTATTCACCTATTTATCTAATTGTCTAGGTGCACACCTACGTAGGTGCATGCA TATTTACGTGTCTAGCTGATCACCTGCCTGCATATTTGCGTATTTGCATGTATATTTGCG CACCTACTTAGCTAGCCACCTACGTAACTACTTGCATACTTACGTGTCTATTTGCATGCG CAGCCACCTAATTAGATACGTAGCTGTTTATCTAATTAGATATGCACCTAGCTATTTGTC TGTCTATTTGCATGCGCAGCCACCTAGATGTTTAGTTACATATTTGCATGCGCAGCCACC TGCCTGTTTAGATACGTGTCTGTTTACTTGTCTAATTAGGTAGACAGCCACCTGTGTAAC TAATTGTCTATTTGCGTGCCTACTTACGTATTCAGCCACCTACTTAGATATCCACCTGCG TGCCTATTTACGTAATTACTTAGCCACCTGCGTGATTAGTTACATAGGTAGCTGCGCAGA CACCTCATTATACACCTGTCTAACTATTCACCTATTTAGATACGTAGGTATCTATTTATC CACCTGTATATTTGCATGCGTAATTAGGTAGACACCTAGGTATACACCTGTCTAACTAAT TGCGCACCTGTCTATTTGACTGTCCACCTACGTACTTAGACACCTACATATTCACCTGCG TGTTTACGTACGTATTTGCGTGCGTATATGTTTAGCTAGCTGATCACCTATCTATTTACG TAGGTATCTATTTATCCACCTACATACTTACGTAAGCACCTGTCTAGGCACCTGTCTAAC TAATTGCGCACCTATTTGACTACTTACGTGTCCACCTACGTAGGTAGATGTCTATTTAGA TGTCCAGCCACCTGTGTAATTGTCTAACTAGGTGTTTGTCCACCTACTTAGATGATCACC TAGTTAATTGCGTGCGTAATTAGATATGCACCTAGGTGCACACCTACGTAACTACTTAGA TATGTATTTATCCACCTACGTAACTACTTGCATACTTACGTGTCTATTTGCATGCGCAGC CACCTGTCTAACTATTTAGACACCTGTCTAACTATTCACCTACGTAGGTGCATATTCACC TAGCTAGGTATGTAATTACGCACCTAGGTATACACCTGTCTAACTATTCACCTATTTATC TAATTGTCTAGGTGCACACCTAATTGCGCACCTGTGTAGGTGCATAAGTAATTAGATATG CACCTACGTAGGTGCATGCATATTTACGTGTCTAGCTGATCAGACACCTTATTAGGTGTT CACCTACGTACTTAGACACCTACTTAGCTGCGTAGGCACCTGTTTGCGTATTCACCTGTC TAACTAATTGCGCACCTGTCTATTTGACTGTCCACCTGTCTAGGCACCTGTCTATTTGCG TGTCCACCTACGTAGGTGCCTGATCAGCCACCTGCCTACTTGCGTGTCTATTCAGCCACC TGTTTAGATATCTAGGCAGCCACCTGCATATTTATCTAGGCAGCCACCTACTTAGATATC CACCTACTTAGATGATCACCTAGGTGTCTAACTATTTGCACACCTATATATTTACTTGTC TGTTTGCATATTTGCGCACCTGATTAGGTGTTCACCTAACTACTTGTATATTCACCTAAT TAGTTGCCTAGCTATTTAGTTATTTAGATGTCTATTTATCCACCTAATTAGACACCTGAT TAGGTGTTTGCACACCTACTTGCCTGCCTAGCTAATTACGTACTTGTCTAATTAGGTAGA CAGACCAACCAATCCATATTTAGCTAGGTGTGCACCTGTCTAACTAATTGCGCACCTGCC TACTTGCATACTTATGTGCATACTTGCCTAACCAGCCACCTGATTAGGTGTTCACCTGTG TAATTAGCTAGCCACCTATATAATTAGATATCCACCTACTCACCTAGCTAGGTAGATATG CACCTGCGTATTTGCTTGTTTATTTAGATACGTATTCACCTAGGTATACACCTCCTTTCG TCCGTCATTCATCACCTACGTAACTACTTGCATACTTACGTGTCTATTTGCATGCGCACC TACTTAGATATCCACCTATTTGACTGTCTATTTAGATATCTATTTATCCACCTGCGTGAT TAGTTACATAGGTAGCTGCGCACCTGTCTAACTACTTGTCCACCTGATTAGGTGTTCACC TACGTACTTAGACACCTGTTTGCGTATTCACCTATATAGGTGCACACCTAGTTAGGTGCA TATTCACCTACTTATCTGTATACTTAGATACGTATTTATCCACCTGTCTATTTGCGTGTC TAATTAGATATGCAGACACCTCGTTACTTAAGTATTCACCTGCGTGTTTGCATATTCACC TGTCTAACTACTTGTCCACCTGATTAGGTGTTTGCACACCTATTTATCTAATTGTCTAGG TGCACACCTAACTACTTAGATATCTAGCTATTTGCGCACCTATTTGTATATTTGCATGAT CACCTGCGTAATTAGATATGTAGCTATTCACCTAGGTAGATATTCACCTAGGTATACACC TGTCTAACTATTTAGTCACCTGTGTAATTGTCTAACTAGGTGTTTGTCCACCTACGTAGG TGCATGCATGTTTGCCTGTCTAATTAGGTAGACAGCCACCTGTCTGCATGTTTAGATACG TACTTGTCTAATTAGGTAGACAGCCACCTAGGTGCACACCTGTTTAGATAATTAGATGTC TATTTAGATATCTATTTATCCACCTAGTTAGGTATCTAATTATATAATTACGTACTTGTC TAATTAGGTAGATGCGCAGACCAACCAATCCTTTCGTCCGTCATTCATCACCCAGGCACC TATTTGACTGTCTATTTAGATATCTATTTATCCACCTACGTAACTACTTGCATACTTACG TGTCTATTTGCATGCGCACCTGTCTATTTGCGTGTCCACCTACATAGCTAGGTACGTAAG CGAACCAACCAACACTCACACACGCCAACATTTTGACATACAACCAATTTGGCAAGCAGT CGGTTTAGTTGTTGAGTGGTCGAGCATGCGAACACACAGCCAGACGGCCGGACAGGCGGG TTGCTGGCCCAACGCCCGCCCGCCCGCTCGCTCGCTCGCACGCACGCACGCGCGCGCGCG CGTCCGTCCGTCCGTTCGTTCGTTCGTACGTACGTACGTGCGTGCGTGCGACCGACCGAC CGATCGATCGATCCAATCCTTCCTTCCTTACTTACTTACTTCCATCCATCCATACATACA TACATCCGTCCGTCCGTACGTACGTACGTCTCTCTCTCTCTATCTATCTATCTCTTTCTT TCTTTATTTATTTATTTCTATCTATCTATATATATATATACCAATGGATGGACACTCACT TCCCTCCCCACGCACGCATCCATCCATTCATTTTGATTGACATACATACAAACAACCAAC CAATCAATTTGGTTGGCAAGCAAGCAGTCAGTCGGTCGGTCAGGCAGGTTGCTTGCCCAA TGGCCACCTGGCTGGCCACCTGGCTGGCTGGCCACCTGGCTGGCTGGCTGGCCACCTGGC TGGCTGGCTGGCTGGCCACCTGGCTGGCTGGCTGGCTGGCCCAATCTTTCGATCTCCAGT TCGGTCTACAGTTCGCTCATTCGATCTTCAGTTTTCTCTTTTCGTTTCCAGTCAGTCGGA TTGGTTGGTTGGTTGGCGGCCAGTCAGTTCTTTCGATCTCCAGTTCGGTCTACAGTTCGC TCATTCGATCTTCAGTTTTCTCTTTTCGTTTCCCAATTAGTTTCTCTTTTCGTTTCCAGT TCCATCGCTCGGTCCGTCAGCAGTTTCGTTTCTCCTTTCATTTCTTGTCCAATTTCTATT TGCGTGTCTTGGCGCTCGCACGCGCAGTTCCTTCCATCCGCAGTTGACTGATTGAACAGT CGATCGATCGATCCAATCCGTAGGTATCTATTCGAACACCTTACCGCTTTATCGCACAGT TTAACGCGTTTGCGTCCAGTTTTCTCTTTTCGTTTCCAGTCGCCCGCCCGCCCGCTCCAA TTCCTACTTGTCTAACCAGTTAGCTAATTAAGTATTCACCCAGGTATATAGGTAGCTATC TATTTGCACAGGTGCGTGTTTACATATATAGGTAGCTATCTATTTGCACAGGTATATAAT TAGCTATTCAGATGTCTGACTGTCCCAATCTTTAGTTACTTAATTAGCCAGTTAGCTAAT TAAGTATTCACCTGTCTATTTGCGTGTCTCCCTATTTGACTACTTAGTTGCCTAGCTATT CAGATACGTAGGTAGTCCAATTTTTTCATCGCCAGTTAGCTAATTAAGTATTCACCTAAC TGTCTGTCTGCCTGCGCGAACAGGCAGGTATTTGACTACTTAGTTGCCTAGCTATTCAGA TACGTAGGTAGTCAGGTGTCTATTTGCGTGTCCGGGTGCCTACTTGCATACTTAGTCGGT CGCTCATATAGGTGTCTAACTATTTGCACGGTCGCACCAATTTCTACTTACATGCGCACC CACCCACCCACCTACTTAGATATCCACCTGCGTGCCTACTTACGTATTTGCGCACCCACC TAGTTAATTGACTATTTATCCACCCACCCACCTGTCTAGGTATGTATTTGTCTAACTATT TGCACCAATTAGTTTCTCTTTTCGTTTCCAGTTCCATCGCTCGGTCCGTCAGCAGTTCTT TCGATCTCTTGTGA test 2 Life grows from simple patterns. Even a small code can carry meaning. AGC-128 is a seed for the future. test 2 TCGCTAATTATATATTCACCTATGTGCATAGGTGTGTGCGCACCTATATGCATAGGTAGT CACCTGCGTAATTAGTTGCCTAGCTATTCACCTGCCTACTTGTCTGTCTATTTGCATAGA TGCGCAGACCAATCTTTGTATATTTAGACACCTACTCACCTGCGTAGTTACTTAGCTAGC CACCTACGTAGGTATCTATTCACCTACGTACTTAGACACCTACGTACTTGCATGCATGAT CACCTAGTTATTTACTTAGATAATTAGATATGCAGACCAATCCTTCTGTCCGCAGTCGCT CGCACGACCACCTAATTGCGCACCTACTCACCTGCGTATTTATTTATCCACCTATATAGG TGCACACCTGTCTAACTATTCACCTATATGTTTGTCTGTTTGCATATTCAGAAA
Official AGC‑128 portal (dark theme, tabs, collapsible docs, checksum engine):
👉 https://AlexKitipov.github.io/AGC_128_document_v.1/