diff --git a/index.html b/index.html
index 5da5ff7..473872b 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Dateisystem-Offset-Rechner (Fixed)</title>
+    <title>Dateisystem-Offset-Rechner</title>
     <style>
         * {
             margin: 0;
@@ -130,7 +130,7 @@
         /* Constants and Calculator Layout */
         .constants-calculator-container {
             display: grid;
-            grid-template-columns: 1fr 1fr;
+            grid-template-columns: 1fr 350px;
             gap: 20px;
             margin-bottom: 20px;
         }
@@ -142,7 +142,7 @@
             }
         }
 
-        /* Calculator Styles */
+        /* Simplified Calculator Styles */
         .hex-calculator {
             background-color: #1a1a1a;
             min-height: fit-content;
@@ -151,14 +151,14 @@
         .calculator-container {
             display: flex;
             flex-direction: column;
-            gap: 15px;
+            gap: 12px;
         }
 
         .calc-display {
             background-color: #111111;
             border: 1px solid #404040;
             border-radius: 6px;
-            padding: 15px;
+            padding: 12px;
         }
 
         .calc-input input {
@@ -168,24 +168,24 @@
             border-radius: 4px;
             color: #ffffff;
             font-family: 'Consolas', monospace;
-            font-size: 18px;
+            font-size: 16px;
             font-weight: bold;
-            padding: 12px;
+            padding: 8px;
             text-align: right;
-            margin-bottom: 12px;
+            margin-bottom: 8px;
         }
 
         .calc-conversions {
             display: flex;
             flex-direction: column;
-            gap: 8px;
+            gap: 4px;
         }
 
         .conversion-row {
             display: flex;
             justify-content: space-between;
             align-items: center;
-            padding: 6px 0;
+            padding: 3px 0;
             border-bottom: 1px solid #333333;
         }
 
@@ -196,14 +196,14 @@
         .conv-label {
             color: #888888;
             font-weight: bold;
-            font-size: 0.9em;
-            min-width: 40px;
+            font-size: 0.8em;
+            min-width: 30px;
         }
 
         .conv-value {
             color: #cccccc;
             font-family: 'Consolas', monospace;
-            font-size: 0.9em;
+            font-size: 0.8em;
             word-break: break-all;
             text-align: right;
             flex: 1;
@@ -213,26 +213,26 @@
         .calc-buttons {
             display: flex;
             flex-direction: column;
-            gap: 8px;
+            gap: 4px;
         }
 
         .calc-row {
             display: grid;
             grid-template-columns: repeat(5, 1fr);
-            gap: 6px;
+            gap: 4px;
         }
 
         .calc-btn {
             background-color: #2a2a2a;
             border: 1px solid #4a4a4a;
-            border-radius: 4px;
+            border-radius: 3px;
             color: #ffffff;
             cursor: pointer;
             font-family: 'Consolas', monospace;
-            font-size: 0.85em;
+            font-size: 0.8em;
             font-weight: bold;
-            min-height: 40px;
-            padding: 8px;
+            min-height: 32px;
+            padding: 4px;
             text-align: center;
             transition: all 0.2s;
             user-select: none;
@@ -265,16 +265,6 @@
             background-color: #3a5a3a;
         }
 
-        .calc-btn.memory {
-            background-color: #4a2a2a;
-            color: #cc8888;
-            font-size: 0.75em;
-        }
-
-        .calc-btn.memory:hover {
-            background-color: #5a3a3a;
-        }
-
         .calc-btn.clear {
             background-color: #4a2a4a;
             color: #cc88cc;
@@ -306,19 +296,6 @@
             grid-column: span 2;
         }
 
-        @media (max-width: 768px) {
-            .calc-btn {
-                min-height: 35px;
-                font-size: 0.8em;
-                padding: 6px;
-            }
-
-            .calc-input input {
-                font-size: 16px;
-                padding: 10px;
-            }
-        }
-
         /* Sections */
         .section {
             background-color: #252525;
@@ -387,6 +364,7 @@
         .input-group {
             display: flex;
             flex-direction: column;
+            position: relative;
         }
 
         .input-group label {
@@ -419,6 +397,18 @@
             background-color: #383838;
         }
 
+        .input-group input.error {
+            border-color: #ff6666;
+            background-color: #332222;
+        }
+
+        .error-message {
+            color: #ff8888;
+            font-size: 0.8em;
+            margin-top: 4px;
+            font-style: italic;
+        }
+
         .result-item {
             display: flex;
             justify-content: space-between;
@@ -432,6 +422,14 @@
             border-bottom: none;
         }
 
+        .result-item.available {
+            opacity: 1;
+        }
+
+        .result-item.unavailable {
+            opacity: 0.5;
+        }
+
         .result-label {
             color: #cccccc;
             font-weight: normal;
@@ -491,30 +489,6 @@
             line-height: 1.4;
         }
 
-        @media (max-width: 600px) {
-            .result-item {
-                flex-direction: column;
-                align-items: flex-start;
-                gap: 5px;
-            }
-
-            .result-value {
-                text-align: left;
-                min-width: auto;
-            }
-        }
-
-        @media (max-width: 600px) {
-            .header-content {
-                flex-direction: column;
-                gap: 10px;
-            }
-
-            .nav {
-                justify-content: center;
-            }
-        }
-
         .error {
             color: #ff8888;
             font-style: italic;
@@ -565,42 +539,38 @@
             font-size: 0.85em;
         }
 
+        /* Result Groups */
+        .result-group {
+            margin-bottom: 20px;
+            border: 1px solid #3a3a3a;
+            border-radius: 6px;
+            padding: 15px;
+            background-color: #2a2a2a;
+        }
+
+        .result-group h3 {
+            color: #ffffff;
+            margin-bottom: 10px;
+            font-size: 1.1em;
+            border-bottom: 1px solid #3a3a3a;
+            padding-bottom: 5px;
+        }
+
         @media (max-width: 768px) {
-            .main-content {
-                padding: 15px;
+            .constants-calculator-container {
+                grid-template-columns: 1fr;
+            }
+            
+            .result-item {
+                flex-direction: column;
+                align-items: flex-start;
+                gap: 5px;
             }
 
-            h1 {
-                font-size: 1.8em;
-                margin-bottom: 20px;
+            .result-value {
+                text-align: left;
+                min-width: auto;
             }
-
-            .section {
-                padding: 15px;
-            }
-
-            .formula-box {
-                padding: 12px;
-                font-size: 0.85em;
-            }
-
-            .tab {
-                padding: 12px 15px;
-                min-width: 100px;
-            }
-        }
-
-        @media (min-width: 1200px) {
-            .input-grid {
-                grid-template-columns: repeat(3, 1fr);
-            }
-        }
-
-        .fix-highlight {
-            background-color: #2a4a2a;
-            padding: 2px 4px;
-            border-radius: 3px;
-            border: 1px solid #4a6a4a;
         }
     </style>
 </head>
@@ -608,17 +578,17 @@
 <body>
     <header class="header">
         <div class="header-content">
-            <div class="logo">Dateisystem-Offset-Rechner (Fixed)</div>
+            <div class="logo">Dateisystem-Offset-Rechner</div>
             <nav class="nav">
-                <a href="#home">Home</a>
-                <a href="mailto:mstoeck3@hs-mittweida.de">Contact</a>
+                <a href="#home">Start</a>
+                <a href="mailto:mstoeck3@hs-mittweida.de">Kontakt</a>
             </nav>
         </div>
     </header>
 
     <main class="main-content">
         <div class="container">
-            <h1>Dateisystem-Offset-Rechner (Fixed Version)</h1>
+            <h1>Dateisystem-Offset-Rechner</h1>
 
             <div class="tabs">
                 <div class="tab active" onclick="switchTab('fat1216')">FAT12/16</div>
@@ -632,20 +602,20 @@
                         <h2>Konstanten</h2>
                         <div class="input-grid">
                             <div class="input-group">
-                                <label for="baseOffset1216">Base Offset <span
-                                        class="unit-indicator">(Bytes)</span>:</label>
+                                <label for="baseOffset1216">Basis-Offset <span class="unit-indicator">(Bytes)</span>:</label>
                                 <input type="text" id="baseOffset1216" value="0x0" placeholder="0x0">
+                                <div class="error-message" id="baseOffset1216-error"></div>
                             </div>
                             <div class="input-group">
-                                <label for="sectorSize1216">Größe eines Sektors <span
-                                        class="unit-indicator">(Bytes)</span>:</label>
+                                <label for="sectorSize1216">Sektorgröße <span class="unit-indicator">(Bytes)</span>:</label>
                                 <input type="text" id="sectorSize1216" value="0x200" placeholder="0x200">
+                                <div class="error-message" id="sectorSize1216-error"></div>
                             </div>
                         </div>
                     </div>
 
                     <div class="section hex-calculator">
-                        <h2>Hex Calculator</h2>
+                        <h2>Hex-Rechner</h2>
                         <div class="calculator-container">
                             <div class="calc-display">
                                 <div class="calc-input">
@@ -667,51 +637,37 @@
                                 </div>
                             </div>
                             <div class="calc-buttons">
-                                <div class="calc-row">
-                                    <button class="calc-btn memory" onclick="calcMemory('MC')">MC</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('MR')">MR</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('M+')">M+</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('M-')">M-</button>
-                                    <button class="calc-btn clear" onclick="calcClear()">C</button>
-                                </div>
                                 <div class="calc-row">
                                     <button class="calc-btn number" onclick="calcInput('A')">A</button>
                                     <button class="calc-btn number" onclick="calcInput('B')">B</button>
                                     <button class="calc-btn number" onclick="calcInput('C')">C</button>
                                     <button class="calc-btn number" onclick="calcInput('D')">D</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('<<')">&lt;&lt;</button>
+                                    <button class="calc-btn clear" onclick="calcClear()">C</button>
                                 </div>
                                 <div class="calc-row">
                                     <button class="calc-btn number" onclick="calcInput('E')">E</button>
                                     <button class="calc-btn number" onclick="calcInput('F')">F</button>
                                     <button class="calc-btn number" onclick="calcInput('7')">7</button>
                                     <button class="calc-btn number" onclick="calcInput('8')">8</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('>>')">&gt;&gt;</button>
-                                </div>
-                                <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('AND')">AND</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('OR')">OR</button>
-                                    <button class="calc-btn number" onclick="calcInput('9')">9</button>
                                     <button class="calc-btn operation" onclick="calcOperation('/')">/</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('MOD')">MOD</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('XOR')">XOR</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('NOT')">NOT</button>
                                     <button class="calc-btn number" onclick="calcInput('4')">4</button>
                                     <button class="calc-btn number" onclick="calcInput('5')">5</button>
                                     <button class="calc-btn number" onclick="calcInput('6')">6</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('*')">*</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('MOD')">MOD</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('*')">*</button>
                                     <button class="calc-btn number" onclick="calcInput('1')">1</button>
                                     <button class="calc-btn number" onclick="calcInput('2')">2</button>
                                     <button class="calc-btn number" onclick="calcInput('3')">3</button>
                                     <button class="calc-btn operation" onclick="calcOperation('-')">-</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('+')">+</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('+')">+</button>
                                     <button class="calc-btn number wide" onclick="calcInput('0')">0</button>
+                                    <button class="calc-btn number" onclick="calcInput('9')">9</button>
                                     <button class="calc-btn backspace" onclick="calcBackspace()">⌫</button>
                                     <button class="calc-btn equals" onclick="calcEquals()">=</button>
                                 </div>
@@ -724,129 +680,163 @@
                     <h2>Eingabeparameter</h2>
                     <div class="input-grid">
                         <div class="input-group">
-                            <label for="reservedSectors1216">Anzahl reservierter Sektoren <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="reservedSectors1216">Reservierte Sektoren <span class="unit-indicator">(Anzahl)</span>:</label>
                             <input type="text" id="reservedSectors1216" placeholder="0x1">
+                            <div class="error-message" id="reservedSectors1216-error"></div>
                         </div>
                         <div class="input-group">
                             <label for="numFATs1216">Anzahl FATs <span class="unit-indicator">(Anzahl)</span>:</label>
                             <input type="text" id="numFATs1216" placeholder="0x2">
+                            <div class="error-message" id="numFATs1216-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="fatSizeSectors1216">Größe einer FAT <span
-                                    class="unit-indicator fix-highlight">(Sektoren)</span>:</label>
+                            <label for="fatSizeSectors1216">FAT-Größe <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="fatSizeSectors1216" placeholder="0x4000">
+                            <div class="error-message" id="fatSizeSectors1216-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="maxRootEntries1216">Max. Wurzelverzeichnis-Einträge <span
-                                    class="unit-indicator">(Anzahl)</span>:</label>
+                            <label for="maxRootEntries1216">Max. Root-Einträge <span class="unit-indicator">(Anzahl)</span>:</label>
                             <input type="text" id="maxRootEntries1216" placeholder="0x200">
+                            <div class="error-message" id="maxRootEntries1216-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="partitionSizeInSectors1216">Größe Partition <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="partitionSizeInSectors1216">Partitionsgröße <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="partitionSizeInSectors1216" placeholder="0x4015">
+                            <div class="error-message" id="partitionSizeInSectors1216-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="clusterSizeSectors1216">Größe eines Clusters <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="clusterSizeSectors1216">Clustergröße <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="clusterSizeSectors1216" placeholder="0x2">
+                            <div class="error-message" id="clusterSizeSectors1216-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="clusterNumber1216">Cluster Nummer für Position <span
-                                    class="unit-indicator">(Nummer)</span>:</label>
+                            <label for="clusterNumber1216">Cluster-Nummer <span class="unit-indicator">(Nummer)</span>:</label>
                             <input type="text" id="clusterNumber1216" placeholder="0x2">
+                            <div class="error-message" id="clusterNumber1216-error"></div>
                         </div>
                     </div>
                 </div>
 
                 <div class="section results">
                     <h2>Berechnete Werte</h2>
-                    <div id="results1216">
-                        <div class="result-item">
-                            <span class="result-label" data-formula="reservedSectors × sectorSize + baseOffset">Beginn
-                                FAT-Bereich:</span>
+                    
+                    <div class="result-group">
+                        <h3>FAT-Struktur</h3>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216">
+                            <span class="result-label" data-formula="reservedSectors × sectorSize + baseOffset">FAT-Bereich Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatStart1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatStart1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatStart1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatStart1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="numFATs × fatSizeSectors * sectorSize">Größe FAT-Bereich:</span>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216">
+                            <span class="result-label" data-formula="fatStart ÷ sectorSize">FAT-Bereich Anfang (Sektor):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatSize1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatSize1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatStartSector1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatStartSector1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="fatStart + fatSize">Ende FAT-Bereich:</span>
+                        <div class="result-item" data-deps="numFATs1216,fatSizeSectors1216,sectorSize1216">
+                            <span class="result-label" data-formula="numFATs × fatSizeSectors × sectorSize">FAT-Bereich Größe (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatEnd1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatEnd1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatSize1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatSize1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="fatEnd">Beginn Wurzelverzeichnis:</span>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,fatSizeSectors1216">
+                            <span class="result-label" data-formula="fatStart + (fatSizeSectors × sectorSize)">FAT2 Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="rootDirStart1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('rootDirStart1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fat2Start1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fat2Start1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="maxRootEntries × 0x20">Größe
-                                Wurzelverzeichnis:</span>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216">
+                            <span class="result-label" data-formula="fatStart + fatSize">FAT-Bereich Ende (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="rootDirSize1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('rootDirSize1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatEnd1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatEnd1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="fatEnd + rootDirSize">Beginn Daten-Bereich:</span>
+                    </div>
+
+                    <div class="result-group">
+                        <h3>Root-Directory</h3>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216">
+                            <span class="result-label" data-formula="fatEnd">Root-Directory Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="dataStart1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('dataStart1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="rootDirStart1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('rootDirStart1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label"
-                                data-formula="(partitionSizeInSectors × sectorSize) - (dataStart - baseOffset)">Größe
-                                Daten-Bereich:</span>
+                        <div class="result-item" data-deps="maxRootEntries1216">
+                            <span class="result-label" data-formula="maxRootEntries × 0x20">Root-Directory Größe (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="dataSize1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('dataSize1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="rootDirSize1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('rootDirSize1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="sectorSize × clusterSizeSectors">Größe eines
-                                Clusters:</span>
+                    </div>
+
+                    <div class="result-group">
+                        <h3>Daten-Bereich</h3>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216">
+                            <span class="result-label" data-formula="fatEnd + rootDirSize">Daten-Bereich Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="clusterSize1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('clusterSize1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="dataStart1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataStart1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216">
+                            <span class="result-label" data-formula="dataStart ÷ sectorSize">Daten-Bereich Anfang (Sektor):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="dataStartSector1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataStartSector1216')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="partitionSizeInSectors1216,sectorSize1216,reservedSectors1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216">
+                            <span class="result-label" data-formula="(partitionSizeInSectors × sectorSize) - (dataStart - baseOffset)">Daten-Bereich Größe (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="dataSize1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataSize1216')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="sectorSize1216,clusterSizeSectors1216">
+                            <span class="result-label" data-formula="sectorSize × clusterSizeSectors">Cluster-Größe (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="clusterSize1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterSize1216')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="partitionSizeInSectors1216,sectorSize1216,reservedSectors1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216,clusterSizeSectors1216">
                             <span class="result-label" data-formula="dataSize ÷ clusterSize">Anzahl Cluster:</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="numClusters1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('numClusters1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="numClusters1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('numClusters1216')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label"
-                                data-formula="dataStart + (clusterNumber - 0x2) × clusterSize">Beginn Cluster:</span>
+                    </div>
+
+                    <div class="result-group">
+                        <h3>Spezifischer Cluster</h3>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216,clusterSizeSectors1216,clusterNumber1216">
+                            <span class="result-label" data-formula="dataStart + (clusterNumber - 0x2) × clusterSize">Cluster Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="clusterStart1216" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('clusterStart1216')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="clusterStart1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterStart1216')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,numFATs1216,fatSizeSectors1216,maxRootEntries1216,clusterSizeSectors1216,clusterNumber1216">
+                            <span class="result-label" data-formula="clusterStart ÷ sectorSize">Cluster Anfang (Sektor):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="clusterStartSector1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterStartSector1216')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="reservedSectors1216,sectorSize1216,baseOffset1216,clusterNumber1216">
+                            <span class="result-label" data-formula="fatStart + (clusterNumber × 2) für FAT16">FAT-Eintrag Position (Bytes, nur FAT16):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="fatEntryPos1216">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatEntryPos1216')">📋</button>
                             </div>
                         </div>
                     </div>
@@ -855,24 +845,17 @@
                 <div class="section formulas">
                     <h2>Berechnungsformeln FAT12/16</h2>
                     <div class="formula-box">
-                        <div class="formula"><span class="calculated">Beginn FAT-Bereich</span> = Anzahl reservierter
-                            Sektoren × Größe eines Sektors + Base Offset</div>
-                        <div class="formula"><span class="calculated">Größe FAT-Bereich</span> = Anzahl FATs × Größe
-                            einer FAT (in Bytes)</div>
-                        <div class="formula"><span class="calculated">Ende FAT-Bereich</span> = Beginn FAT-Bereich +
-                            Größe FAT-Bereich</div>
-                        <div class="formula"><span class="calculated">Größe Wurzelverzeichnis</span> = Anzahl max.
-                            Wurzelverzeichnis-Einträge × 0x20</div>
-                        <div class="formula"><span class="calculated">Beginn Daten-Bereich</span> = Ende FAT-Bereich +
-                            Größe Wurzelverzeichnis</div>
-                        <div class="formula"><span class="calculated">Größe Daten-Bereich</span> = (Größe Partition in
-                            Sektoren × Größe eines Sektors) - (Beginn Daten-Bereich - Base Offset)</div>
-                        <div class="formula"><span class="calculated">Größe eines Clusters</span> = Größe eines Sektors
-                            × Größe eines Clusters in Sektoren</div>
-                        <div class="formula"><span class="calculated">Anzahl Cluster</span> = Größe Daten-Bereich ÷
-                            Größe eines Clusters</div>
-                        <div class="formula"><span class="calculated">Beginn Cluster</span> = Beginn Daten-Bereich +
-                            (Cluster - 0x2) × Größe eines Clusters</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Anfang</span> = Reservierte Sektoren × Sektorgröße + Basis-Offset</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Größe</span> = Anzahl FATs × FAT-Größe in Sektoren × Sektorgröße</div>
+                        <div class="formula"><span class="calculated">FAT2 Anfang</span> = FAT-Bereich Anfang + FAT-Größe in Bytes</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Ende</span> = FAT-Bereich Anfang + FAT-Bereich Größe</div>
+                        <div class="formula"><span class="calculated">Root-Directory Größe</span> = Max. Root-Einträge × 0x20</div>
+                        <div class="formula"><span class="calculated">Daten-Bereich Anfang</span> = FAT-Bereich Ende + Root-Directory Größe</div>
+                        <div class="formula"><span class="calculated">Daten-Bereich Größe</span> = (Partitionsgröße × Sektorgröße) - (Daten-Bereich Anfang - Basis-Offset)</div>
+                        <div class="formula"><span class="calculated">Cluster-Größe</span> = Sektorgröße × Cluster-Größe in Sektoren</div>
+                        <div class="formula"><span class="calculated">Anzahl Cluster</span> = Daten-Bereich Größe ÷ Cluster-Größe</div>
+                        <div class="formula"><span class="calculated">Cluster Anfang</span> = Daten-Bereich Anfang + (Cluster-Nummer - 0x2) × Cluster-Größe</div>
+                        <div class="formula"><span class="calculated">FAT-Eintrag Position</span> = FAT-Bereich Anfang + (Cluster-Nummer × Eintraggröße)</div>
                     </div>
                 </div>
             </div>
@@ -884,20 +867,20 @@
                         <h2>Konstanten</h2>
                         <div class="input-grid">
                             <div class="input-group">
-                                <label for="baseOffset32">Base Offset <span
-                                        class="unit-indicator">(Bytes)</span>:</label>
+                                <label for="baseOffset32">Basis-Offset <span class="unit-indicator">(Bytes)</span>:</label>
                                 <input type="text" id="baseOffset32" value="0x0" placeholder="0x0">
+                                <div class="error-message" id="baseOffset32-error"></div>
                             </div>
                             <div class="input-group">
-                                <label for="sectorSize32">Größe eines Sektors <span
-                                        class="unit-indicator">(Bytes)</span>:</label>
+                                <label for="sectorSize32">Sektorgröße <span class="unit-indicator">(Bytes)</span>:</label>
                                 <input type="text" id="sectorSize32" value="0x200" placeholder="0x200">
+                                <div class="error-message" id="sectorSize32-error"></div>
                             </div>
                         </div>
                     </div>
 
                     <div class="section hex-calculator">
-                        <h2>Hex Calculator</h2>
+                        <h2>Hex-Rechner</h2>
                         <div class="calculator-container">
                             <div class="calc-display">
                                 <div class="calc-input">
@@ -920,59 +903,38 @@
                             </div>
                             <div class="calc-buttons">
                                 <div class="calc-row">
-                                    <button class="calc-btn memory" onclick="calcMemory('MC', 'fat32')">MC</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('MR', 'fat32')">MR</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('M+', 'fat32')">M+</button>
-                                    <button class="calc-btn memory" onclick="calcMemory('M-', 'fat32')">M-</button>
-                                    <button class="calc-btn clear" onclick="calcClear('fat32')">C</button>
+                                    <button class="calc-btn number" onclick="calcInput('A')">A</button>
+                                    <button class="calc-btn number" onclick="calcInput('B')">B</button>
+                                    <button class="calc-btn number" onclick="calcInput('C')">C</button>
+                                    <button class="calc-btn number" onclick="calcInput('D')">D</button>
+                                    <button class="calc-btn clear" onclick="calcClear()">C</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn number" onclick="calcInput('A', 'fat32')">A</button>
-                                    <button class="calc-btn number" onclick="calcInput('B', 'fat32')">B</button>
-                                    <button class="calc-btn number" onclick="calcInput('C', 'fat32')">C</button>
-                                    <button class="calc-btn number" onclick="calcInput('D', 'fat32')">D</button>
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('<<', 'fat32')">&lt;&lt;</button>
+                                    <button class="calc-btn number" onclick="calcInput('E')">E</button>
+                                    <button class="calc-btn number" onclick="calcInput('F')">F</button>
+                                    <button class="calc-btn number" onclick="calcInput('7')">7</button>
+                                    <button class="calc-btn number" onclick="calcInput('8')">8</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('/')">/</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn number" onclick="calcInput('E', 'fat32')">E</button>
-                                    <button class="calc-btn number" onclick="calcInput('F', 'fat32')">F</button>
-                                    <button class="calc-btn number" onclick="calcInput('7', 'fat32')">7</button>
-                                    <button class="calc-btn number" onclick="calcInput('8', 'fat32')">8</button>
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('>>', 'fat32')">&gt;&gt;</button>
+                                    <button class="calc-btn number" onclick="calcInput('4')">4</button>
+                                    <button class="calc-btn number" onclick="calcInput('5')">5</button>
+                                    <button class="calc-btn number" onclick="calcInput('6')">6</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('*')">*</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('MOD')">MOD</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('AND', 'fat32')">AND</button>
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('OR', 'fat32')">OR</button>
-                                    <button class="calc-btn number" onclick="calcInput('9', 'fat32')">9</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('/', 'fat32')">/</button>
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('MOD', 'fat32')">MOD</button>
+                                    <button class="calc-btn number" onclick="calcInput('1')">1</button>
+                                    <button class="calc-btn number" onclick="calcInput('2')">2</button>
+                                    <button class="calc-btn number" onclick="calcInput('3')">3</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('-')">-</button>
+                                    <button class="calc-btn operation" onclick="calcOperation('+')">+</button>
                                 </div>
                                 <div class="calc-row">
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('XOR', 'fat32')">XOR</button>
-                                    <button class="calc-btn operation"
-                                        onclick="calcOperation('NOT', 'fat32')">NOT</button>
-                                    <button class="calc-btn number" onclick="calcInput('4', 'fat32')">4</button>
-                                    <button class="calc-btn number" onclick="calcInput('5', 'fat32')">5</button>
-                                    <button class="calc-btn number" onclick="calcInput('6', 'fat32')">6</button>
-                                </div>
-                                <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('*', 'fat32')">*</button>
-                                    <button class="calc-btn number" onclick="calcInput('1', 'fat32')">1</button>
-                                    <button class="calc-btn number" onclick="calcInput('2', 'fat32')">2</button>
-                                    <button class="calc-btn number" onclick="calcInput('3', 'fat32')">3</button>
-                                    <button class="calc-btn operation" onclick="calcOperation('-', 'fat32')">-</button>
-                                </div>
-                                <div class="calc-row">
-                                    <button class="calc-btn operation" onclick="calcOperation('+', 'fat32')">+</button>
-                                    <button class="calc-btn number wide" onclick="calcInput('0', 'fat32')">0</button>
-                                    <button class="calc-btn backspace" onclick="calcBackspace('fat32')">⌫</button>
-                                    <button class="calc-btn equals" onclick="calcEquals('fat32')">=</button>
+                                    <button class="calc-btn number wide" onclick="calcInput('0')">0</button>
+                                    <button class="calc-btn number" onclick="calcInput('9')">9</button>
+                                    <button class="calc-btn backspace" onclick="calcBackspace()">⌫</button>
+                                    <button class="calc-btn equals" onclick="calcEquals()">=</button>
                                 </div>
                             </div>
                         </div>
@@ -983,122 +945,152 @@
                     <h2>Eingabeparameter</h2>
                     <div class="input-grid">
                         <div class="input-group">
-                            <label for="reservedSectors32">Anzahl reservierter Sektoren <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="reservedSectors32">Reservierte Sektoren <span class="unit-indicator">(Anzahl)</span>:</label>
                             <input type="text" id="reservedSectors32" placeholder="0x20">
+                            <div class="error-message" id="reservedSectors32-error"></div>
                         </div>
                         <div class="input-group">
                             <label for="numFATs32">Anzahl FATs <span class="unit-indicator">(Anzahl)</span>:</label>
                             <input type="text" id="numFATs32" placeholder="0x2">
+                            <div class="error-message" id="numFATs32-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="fatSizeSectors32">Größe einer FAT <span
-                                    class="unit-indicator fix-highlight">(Sektoren)</span>:</label>
+                            <label for="fatSizeSectors32">FAT-Größe <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="fatSizeSectors32" placeholder="0x20000">
+                            <div class="error-message" id="fatSizeSectors32-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="rootDirCluster32">Root Directory Cluster <span
-                                    class="unit-indicator">(Nummer)</span>:</label>
+                            <label for="rootDirCluster32">Root-Directory Cluster <span class="unit-indicator">(Nummer)</span>:</label>
                             <input type="text" id="rootDirCluster32" placeholder="0x2">
+                            <div class="error-message" id="rootDirCluster32-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="partitionSizeInSectors32">Größe Partition <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="partitionSizeInSectors32">Partitionsgröße <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="partitionSizeInSectors32" placeholder="0x100000">
+                            <div class="error-message" id="partitionSizeInSectors32-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="clusterSizeSectors32">Größe eines Clusters <span
-                                    class="unit-indicator">(Sektoren)</span>:</label>
+                            <label for="clusterSizeSectors32">Clustergröße <span class="unit-indicator">(Sektoren)</span>:</label>
                             <input type="text" id="clusterSizeSectors32" placeholder="0x8">
+                            <div class="error-message" id="clusterSizeSectors32-error"></div>
                         </div>
                         <div class="input-group">
-                            <label for="clusterNumber32">Cluster Nummer für Position <span
-                                    class="unit-indicator">(Nummer)</span>:</label>
+                            <label for="clusterNumber32">Cluster-Nummer <span class="unit-indicator">(Nummer)</span>:</label>
                             <input type="text" id="clusterNumber32" placeholder="0x2">
+                            <div class="error-message" id="clusterNumber32-error"></div>
                         </div>
                     </div>
                 </div>
 
                 <div class="section results">
                     <h2>Berechnete Werte</h2>
-                    <div id="results32">
-                        <div class="result-item">
-                            <span class="result-label" data-formula="reservedSectors × sectorSize + baseOffset">Beginn
-                                FAT-Bereich:</span>
+                    
+                    <div class="result-group">
+                        <h3>FAT-Struktur</h3>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32">
+                            <span class="result-label" data-formula="reservedSectors × sectorSize + baseOffset">FAT-Bereich Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatStart32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatStart32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatStart32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatStart32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="numFATs × fatSizeSectors * sectorSize">Größe FAT-Bereich:</span>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32">
+                            <span class="result-label" data-formula="fatStart ÷ sectorSize">FAT-Bereich Anfang (Sektor):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatSize32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatSize32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatStartSector32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatStartSector32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="fatStart + fatSize">Ende FAT-Bereich:</span>
+                        <div class="result-item" data-deps="numFATs32,fatSizeSectors32,sectorSize32">
+                            <span class="result-label" data-formula="numFATs × fatSizeSectors × sectorSize">FAT-Bereich Größe (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="fatEnd32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('fatEnd32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatSize32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatSize32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="fatEnd">Beginn Daten-Bereich:</span>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,fatSizeSectors32">
+                            <span class="result-label" data-formula="fatStart + (fatSizeSectors × sectorSize)">FAT2 Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="dataStart32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('dataStart32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fat2Start32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fat2Start32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label"
-                                data-formula="(partitionSizeInSectors × sectorSize) - (dataStart - baseOffset)">Größe
-                                Daten-Bereich:</span>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32">
+                            <span class="result-label" data-formula="fatStart + fatSize">FAT-Bereich Ende (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="dataSize32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('dataSize32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="fatEnd32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatEnd32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label" data-formula="sectorSize × clusterSizeSectors">Größe eines
-                                Clusters:</span>
+                    </div>
+
+                    <div class="result-group">
+                        <h3>Daten-Bereich</h3>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32">
+                            <span class="result-label" data-formula="fatEnd">Daten-Bereich Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="clusterSize32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('clusterSize32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="dataStart32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataStart32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32">
+                            <span class="result-label" data-formula="dataStart ÷ sectorSize">Daten-Bereich Anfang (Sektor):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="dataStartSector32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataStartSector32')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="partitionSizeInSectors32,sectorSize32,reservedSectors32,baseOffset32,numFATs32,fatSizeSectors32">
+                            <span class="result-label" data-formula="(partitionSizeInSectors × sectorSize) - (dataStart - baseOffset)">Daten-Bereich Größe (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="dataSize32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('dataSize32')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="sectorSize32,clusterSizeSectors32">
+                            <span class="result-label" data-formula="sectorSize × clusterSizeSectors">Cluster-Größe (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="clusterSize32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterSize32')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="partitionSizeInSectors32,sectorSize32,reservedSectors32,baseOffset32,numFATs32,fatSizeSectors32,clusterSizeSectors32">
                             <span class="result-label" data-formula="dataSize ÷ clusterSize">Anzahl Cluster:</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="numClusters32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('numClusters32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="numClusters32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('numClusters32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label"
-                                data-formula="dataStart + (clusterNumber - 0x2) × clusterSize">Beginn Cluster:</span>
+                    </div>
+
+                    <div class="result-group">
+                        <h3>Spezifischer Cluster</h3>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32,clusterSizeSectors32,clusterNumber32">
+                            <span class="result-label" data-formula="dataStart + (clusterNumber - 0x2) × clusterSize">Cluster Anfang (Bytes):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="clusterStart32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('clusterStart32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="clusterStart32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterStart32')">📋</button>
                             </div>
                         </div>
-                        <div class="result-item">
-                            <span class="result-label"
-                                data-formula="dataStart + (rootDirCluster - 0x2) × clusterSize">Root Directory
-                                Position:</span>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32,clusterSizeSectors32,clusterNumber32">
+                            <span class="result-label" data-formula="clusterStart ÷ sectorSize">Cluster Anfang (Sektor):</span>
                             <div class="result-value-container">
-                                <span class="result-value" id="rootDirPos32" data-result-formula="">-</span>
-                                <button class="copy-btn" onclick="copyToClipboard('rootDirPos32')"
-                                    title="Copy to clipboard">📋</button>
+                                <span class="result-value" id="clusterStartSector32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('clusterStartSector32')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,clusterNumber32">
+                            <span class="result-label" data-formula="fatStart + (clusterNumber × 4)">FAT-Eintrag Position (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="fatEntryPos32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('fatEntryPos32')">📋</button>
+                            </div>
+                        </div>
+                        <div class="result-item" data-deps="reservedSectors32,sectorSize32,baseOffset32,numFATs32,fatSizeSectors32,clusterSizeSectors32,rootDirCluster32">
+                            <span class="result-label" data-formula="dataStart + (rootDirCluster - 0x2) × clusterSize">Root-Directory Position (Bytes):</span>
+                            <div class="result-value-container">
+                                <span class="result-value" id="rootDirPos32">-</span>
+                                <button class="copy-btn" onclick="copyToClipboard('rootDirPos32')">📋</button>
                             </div>
                         </div>
                     </div>
@@ -1107,24 +1099,17 @@
                 <div class="section formulas">
                     <h2>Berechnungsformeln FAT32</h2>
                     <div class="formula-box">
-                        <div class="formula"><span class="calculated">Beginn FAT-Bereich</span> = Anzahl reservierter
-                            Sektoren × Größe eines Sektors + Base Offset</div>
-                        <div class="formula"><span class="calculated">Größe FAT-Bereich</span> = Anzahl FATs × Größe
-                            einer FAT (in Bytes)</div>
-                        <div class="formula"><span class="calculated">Ende FAT-Bereich</span> = Beginn FAT-Bereich +
-                            Größe FAT-Bereich</div>
-                        <div class="formula"><span class="calculated">Beginn Daten-Bereich</span> = Ende FAT-Bereich
-                            (kein festes Root Directory)</div>
-                        <div class="formula"><span class="calculated">Größe Daten-Bereich</span> = (Größe Partition in
-                            Sektoren × Größe eines Sektors) - (Beginn Daten-Bereich - Base Offset)</div>
-                        <div class="formula"><span class="calculated">Größe eines Clusters</span> = Größe eines Sektors
-                            × Größe eines Clusters in Sektoren</div>
-                        <div class="formula"><span class="calculated">Anzahl Cluster</span> = Größe Daten-Bereich ÷
-                            Größe eines Clusters</div>
-                        <div class="formula"><span class="calculated">Beginn Cluster</span> = Beginn Daten-Bereich +
-                            (Cluster - 0x2) × Größe eines Clusters</div>
-                        <div class="formula"><span class="calculated">Root Directory Position</span> = Beginn
-                            Daten-Bereich + (Root Directory Cluster - 0x2) × Größe eines Clusters</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Anfang</span> = Reservierte Sektoren × Sektorgröße + Basis-Offset</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Größe</span> = Anzahl FATs × FAT-Größe in Sektoren × Sektorgröße</div>
+                        <div class="formula"><span class="calculated">FAT2 Anfang</span> = FAT-Bereich Anfang + FAT-Größe in Bytes</div>
+                        <div class="formula"><span class="calculated">FAT-Bereich Ende</span> = FAT-Bereich Anfang + FAT-Bereich Größe</div>
+                        <div class="formula"><span class="calculated">Daten-Bereich Anfang</span> = FAT-Bereich Ende (kein festes Root Directory)</div>
+                        <div class="formula"><span class="calculated">Daten-Bereich Größe</span> = (Partitionsgröße × Sektorgröße) - (Daten-Bereich Anfang - Basis-Offset)</div>
+                        <div class="formula"><span class="calculated">Cluster-Größe</span> = Sektorgröße × Cluster-Größe in Sektoren</div>
+                        <div class="formula"><span class="calculated">Anzahl Cluster</span> = Daten-Bereich Größe ÷ Cluster-Größe</div>
+                        <div class="formula"><span class="calculated">Cluster Anfang</span> = Daten-Bereich Anfang + (Cluster-Nummer - 0x2) × Cluster-Größe</div>
+                        <div class="formula"><span class="calculated">FAT-Eintrag Position</span> = FAT-Bereich Anfang + (Cluster-Nummer × 4)</div>
+                        <div class="formula"><span class="calculated">Root-Directory Position</span> = Daten-Bereich Anfang + (Root-Directory Cluster - 0x2) × Cluster-Größe</div>
                     </div>
                 </div>
             </div>
@@ -1134,59 +1119,39 @@
     <footer class="footer">
         <div class="footer-content">
             <div class="footer-section">
-                <h3>About</h3>
-                <p>Fixed offset calculator for educational and forensic purposes.</p>
-                <p>Version 0.2.1 (Fixed)</p>
+                <h3>Über</h3>
+                <p>Dateisystem Offset-Rechner für Bildung und Forensik.</p>
+                <p>Version 0.3.0</p>
             </div>
             <div class="footer-section">
                 <h3>Support</h3>
-                <a href="mailto:mstoeck3@hs-mittweida.de">Contact Support</a>
-            </div>
-            <div class="footer-section">
-                <h3>Legal</h3>
-                <p>Educational use only</p>
+                <a href="mailto:mstoeck3@hs-mittweida.de">Kontakt</a>
             </div>
         </div>
         <div class="footer-bottom">
-            <p>&copy; 2025 Offset Calculator (Fixed). All rights reserved.</p>
+            <p>&copy; 2025 Dateisystem Offset-Rechner. Public Domain unter BSD-3-Clause.</p>
         </div>
     </footer>
 
     <script>
-        // Global tooltip element
+        // Global state
         let tooltip = null;
-
-        // Calculator state
         const calculatorState = {
-            fat1216: {
-                currentValue: 0,
-                previousValue: 0,
-                operation: null,
-                waitingForOperand: false,
-                memory: 0
-            },
-            fat32: {
-                currentValue: 0,
-                previousValue: 0,
-                operation: null,
-                waitingForOperand: false,
-                memory: 0
-            }
+            currentValue: 0,
+            previousValue: 0,
+            operation: null,
+            waitingForOperand: false
         };
 
+        // Get current active tab
         function getCurrentTab() {
             const activeTab = document.querySelector('.tab-content.active');
-            return activeTab.id === 'fat32' ? 'fat32' : 'fat1216';
+            return activeTab ? activeTab.id : 'fat1216';
         }
 
-        function getCalculatorState(tab = null) {
-            const currentTab = tab || getCurrentTab();
-            return currentTab === 'fat32' ? calculatorState.fat32 : calculatorState.fat1216;
-        }
-
-        function updateCalculatorDisplay(tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
+        // Calculator functions (unified for both tabs)
+        function updateCalculatorDisplay() {
+            const currentTab = getCurrentTab();
             const suffix = currentTab === 'fat32' ? '32' : '';
 
             const inputElement = document.getElementById(`calcInput${suffix}`);
@@ -1194,73 +1159,53 @@
             const decElement = document.getElementById(`decValue${suffix}`);
             const binElement = document.getElementById(`binValue${suffix}`);
 
-            // Ensure value is within JavaScript's safe integer range and non-negative
-            const value = Math.max(0, Math.min(Math.floor(state.currentValue), Number.MAX_SAFE_INTEGER));
+            const value = Math.max(0, Math.min(Math.floor(calculatorState.currentValue), Number.MAX_SAFE_INTEGER));
 
             const hexStr = '0x' + value.toString(16).toUpperCase();
             const decStr = value.toString(10);
             const binStr = '0b' + value.toString(2);
 
-            inputElement.value = hexStr;
-            hexElement.textContent = hexStr;
-            decElement.textContent = decStr;
-            binElement.textContent = binStr;
+            if (inputElement) inputElement.value = hexStr;
+            if (hexElement) hexElement.textContent = hexStr;
+            if (decElement) decElement.textContent = decStr;
+            if (binElement) binElement.textContent = binStr;
         }
 
-        function calcInput(digit, tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
-
-            if (state.waitingForOperand) {
-                state.currentValue = 0;
-                state.waitingForOperand = false;
+        function calcInput(digit) {
+            if (calculatorState.waitingForOperand) {
+                calculatorState.currentValue = 0;
+                calculatorState.waitingForOperand = false;
             }
 
-            // Convert hex digit to number
             const digitValue = parseInt(digit, 16);
             if (isNaN(digitValue)) return;
 
-            // Prevent overflow by limiting to a reasonable hex value
-            const newValue = state.currentValue * 16 + digitValue;
+            const newValue = calculatorState.currentValue * 16 + digitValue;
             if (newValue <= Number.MAX_SAFE_INTEGER && newValue >= 0) {
-                state.currentValue = newValue;
+                calculatorState.currentValue = newValue;
             }
 
-            updateCalculatorDisplay(currentTab);
+            updateCalculatorDisplay();
         }
 
-        function calcOperation(operation, tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
-
-            if (operation === 'NOT') {
-                // Unary operation - apply immediately
-                // Use a mask to ensure we get meaningful results for filesystem calculations
-                state.currentValue = (~state.currentValue & 0xFFFFFFFF) >>> 0;
-                updateCalculatorDisplay(currentTab);
-                return;
+        function calcOperation(operation) {
+            if (calculatorState.previousValue !== 0 && !calculatorState.waitingForOperand) {
+                calcEquals(false);
             }
 
-            if (state.previousValue !== 0 && !state.waitingForOperand) {
-                calcEquals(currentTab, false);
-            }
-
-            state.previousValue = state.currentValue;
-            state.operation = operation;
-            state.waitingForOperand = true;
+            calculatorState.previousValue = calculatorState.currentValue;
+            calculatorState.operation = operation;
+            calculatorState.waitingForOperand = true;
         }
 
-        function calcEquals(tab = null, updateDisplay = true) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
-
-            if (state.operation && state.previousValue !== null) {
-                const prev = Math.floor(state.previousValue);
-                const curr = Math.floor(state.currentValue);
+        function calcEquals(updateDisplay = true) {
+            if (calculatorState.operation && calculatorState.previousValue !== null) {
+                const prev = Math.floor(calculatorState.previousValue);
+                const curr = Math.floor(calculatorState.currentValue);
 
                 try {
                     let result = 0;
-                    switch (state.operation) {
+                    switch (calculatorState.operation) {
                         case '+':
                             result = prev + curr;
                             break;
@@ -1272,100 +1217,294 @@
                             break;
                         case '/':
                             if (curr === 0) {
-                                alert('Division by zero!');
+                                alert('Division durch Null!');
                                 return;
                             }
                             result = Math.floor(prev / curr);
                             break;
                         case 'MOD':
                             if (curr === 0) {
-                                alert('Modulo by zero!');
+                                alert('Modulo durch Null!');
                                 return;
                             }
                             result = prev % curr;
                             break;
-                        case 'AND':
-                            result = (prev & curr);
-                            break;
-                        case 'OR':
-                            result = (prev | curr);
-                            break;
-                        case 'XOR':
-                            result = (prev ^ curr);
-                            break;
-                        case '<<':
-                            // Limit shift amount to prevent overflow
-                            const shiftLeft = Math.min(curr, 53);
-                            result = prev << shiftLeft;
-                            break;
-                        case '>>':
-                            result = prev >> curr;
-                            break;
                     }
 
-                    // Ensure result is within safe range and non-negative
-                    state.currentValue = Math.max(0, Math.min(result, Number.MAX_SAFE_INTEGER));
+                    calculatorState.currentValue = Math.max(0, Math.min(result, Number.MAX_SAFE_INTEGER));
 
                 } catch (error) {
-                    alert('Calculation error: ' + error.message);
-                    state.currentValue = 0;
+                    alert('Berechnungsfehler: ' + error.message);
+                    calculatorState.currentValue = 0;
                 }
 
-                state.operation = null;
-                state.previousValue = 0;
-                state.waitingForOperand = true;
+                calculatorState.operation = null;
+                calculatorState.previousValue = 0;
+                calculatorState.waitingForOperand = true;
             }
 
             if (updateDisplay) {
-                updateCalculatorDisplay(currentTab);
+                updateCalculatorDisplay();
             }
         }
 
-        function calcClear(tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
-
-            state.currentValue = 0;
-            state.previousValue = 0;
-            state.operation = null;
-            state.waitingForOperand = false;
-
-            updateCalculatorDisplay(currentTab);
+        function calcClear() {
+            calculatorState.currentValue = 0;
+            calculatorState.previousValue = 0;
+            calculatorState.operation = null;
+            calculatorState.waitingForOperand = false;
+            updateCalculatorDisplay();
         }
 
-        function calcBackspace(tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
-
-            if (!state.waitingForOperand) {
-                state.currentValue = Math.floor(state.currentValue / 16);
-                updateCalculatorDisplay(currentTab);
+        function calcBackspace() {
+            if (!calculatorState.waitingForOperand) {
+                calculatorState.currentValue = Math.floor(calculatorState.currentValue / 16);
+                updateCalculatorDisplay();
             }
         }
 
-        function calcMemory(operation, tab = null) {
-            const currentTab = tab || getCurrentTab();
-            const state = getCalculatorState(currentTab);
+        // Input validation and parsing
+        function parseHex(value) {
+            if (!value) return 0;
+            let cleanValue = value.toString().trim();
+            if (cleanValue.startsWith('0x') || cleanValue.startsWith('0X')) {
+                cleanValue = cleanValue.substring(2);
+            }
+            const parsed = parseInt(cleanValue, 16);
+            return isNaN(parsed) ? null : Math.max(0, parsed);
+        }
 
-            switch (operation) {
-                case 'MC':
-                    state.memory = 0;
-                    break;
-                case 'MR':
-                    state.currentValue = state.memory;
-                    state.waitingForOperand = false;
-                    updateCalculatorDisplay(currentTab);
-                    break;
-                case 'M+':
-                    state.memory = Math.max(0, Math.min(state.memory + state.currentValue, Number.MAX_SAFE_INTEGER));
-                    break;
-                case 'M-':
-                    state.memory = Math.max(0, state.memory - state.currentValue);
-                    break;
+        function validateInput(fieldId, value) {
+            const parsedValue = parseHex(value);
+            const errorElement = document.getElementById(fieldId + '-error');
+            const inputElement = document.getElementById(fieldId);
+            
+            if (parsedValue === null && value.trim() !== '') {
+                errorElement.textContent = 'Ungültiger Hex-Wert';
+                inputElement.classList.add('error');
+                return false;
+            } else {
+                errorElement.textContent = '';
+                inputElement.classList.remove('error');
+                return true;
             }
         }
 
-        // Create tooltip element
+        function formatHex(value) {
+            if (isNaN(value) || value < 0) {
+                return '<span class="error">Fehler</span>';
+            }
+            return '0x' + Math.floor(value).toString(16).toUpperCase();
+        }
+
+        // Dependency checking
+        function checkDependencies(deps, currentTab) {
+            return deps.every(dep => {
+                const element = document.getElementById(dep);
+                return element && element.value.trim() !== '' && validateInput(dep, element.value);
+            });
+        }
+
+        function updateResultItem(elementId, value, available, calculation = '') {
+            const element = document.getElementById(elementId);
+            const resultItem = element.closest('.result-item');
+            
+            if (available) {
+                element.innerHTML = formatHex(value);
+                resultItem.classList.remove('unavailable');
+                resultItem.classList.add('available');
+                if (calculation) {
+                    element.setAttribute('data-result-formula', calculation);
+                }
+            } else {
+                element.innerHTML = '-';
+                resultItem.classList.remove('available');
+                resultItem.classList.add('unavailable');
+                element.removeAttribute('data-result-formula');
+            }
+        }
+
+        // Calculation functions
+        function calculateValues(tab) {
+            const suffix = tab === 'fat32' ? '32' : '1216';
+            
+            // Get all input values
+            const baseOffset = parseHex(document.getElementById(`baseOffset${suffix === '32' ? '32' : '1216'}`).value) || 0;
+            const sectorSize = parseHex(document.getElementById(`sectorSize${suffix === '32' ? '32' : '1216'}`).value) || 0;
+            const reservedSectors = parseHex(document.getElementById(`reservedSectors${suffix}`).value);
+            const numFATs = parseHex(document.getElementById(`numFATs${suffix}`).value);
+            const fatSizeSectors = parseHex(document.getElementById(`fatSizeSectors${suffix}`).value);
+            const partitionSizeInSectors = parseHex(document.getElementById(`partitionSizeInSectors${suffix}`).value);
+            const clusterSizeSectors = parseHex(document.getElementById(`clusterSizeSectors${suffix}`).value);
+            const clusterNumber = parseHex(document.getElementById(`clusterNumber${suffix}`).value);
+            
+            // FAT12/16 specific
+            const maxRootEntries = tab === 'fat1216' ? parseHex(document.getElementById('maxRootEntries1216').value) : null;
+            
+            // FAT32 specific
+            const rootDirCluster = tab === 'fat32' ? parseHex(document.getElementById('rootDirCluster32').value) : null;
+
+            // Check each calculation's dependencies and calculate if available
+            const results = {};
+
+            // FAT Start
+            if (checkDependencies([`reservedSectors${suffix}`, `sectorSize${suffix === '32' ? '32' : '1216'}`, `baseOffset${suffix === '32' ? '32' : '1216'}`], tab)) {
+                results.fatStart = reservedSectors * sectorSize + baseOffset;
+                results.fatStartSector = Math.floor(results.fatStart / sectorSize);
+                updateResultItem(`fatStart${suffix}`, results.fatStart, true, 
+                    `0x${reservedSectors.toString(16)} × 0x${sectorSize.toString(16)} + 0x${baseOffset.toString(16)} = 0x${results.fatStart.toString(16)}`);
+                updateResultItem(`fatStartSector${suffix}`, results.fatStartSector, true,
+                    `0x${results.fatStart.toString(16)} ÷ 0x${sectorSize.toString(16)} = 0x${results.fatStartSector.toString(16)}`);
+            } else {
+                updateResultItem(`fatStart${suffix}`, 0, false);
+                updateResultItem(`fatStartSector${suffix}`, 0, false);
+            }
+
+            // FAT Size
+            if (checkDependencies([`numFATs${suffix}`, `fatSizeSectors${suffix}`, `sectorSize${suffix === '32' ? '32' : '1216'}`], tab)) {
+                results.fatSize = numFATs * fatSizeSectors * sectorSize;
+                updateResultItem(`fatSize${suffix}`, results.fatSize, true,
+                    `0x${numFATs.toString(16)} × 0x${fatSizeSectors.toString(16)} × 0x${sectorSize.toString(16)} = 0x${results.fatSize.toString(16)}`);
+            } else {
+                updateResultItem(`fatSize${suffix}`, 0, false);
+            }
+
+            // FAT2 Start (second FAT copy)
+            if (checkDependencies([`reservedSectors${suffix}`, `sectorSize${suffix === '32' ? '32' : '1216'}`, `baseOffset${suffix === '32' ? '32' : '1216'}`, `fatSizeSectors${suffix}`], tab)) {
+                results.fat2Start = results.fatStart + (fatSizeSectors * sectorSize);
+                updateResultItem(`fat2Start${suffix}`, results.fat2Start, true,
+                    `0x${results.fatStart.toString(16)} + 0x${(fatSizeSectors * sectorSize).toString(16)} = 0x${results.fat2Start.toString(16)}`);
+            } else {
+                updateResultItem(`fat2Start${suffix}`, 0, false);
+            }
+
+            // FAT End
+            if (results.fatStart !== undefined && results.fatSize !== undefined) {
+                results.fatEnd = results.fatStart + results.fatSize;
+                updateResultItem(`fatEnd${suffix}`, results.fatEnd, true,
+                    `0x${results.fatStart.toString(16)} + 0x${results.fatSize.toString(16)} = 0x${results.fatEnd.toString(16)}`);
+            } else {
+                updateResultItem(`fatEnd${suffix}`, 0, false);
+            }
+
+            // Root Directory (FAT12/16 only)
+            if (tab === 'fat1216') {
+                if (checkDependencies(['maxRootEntries1216'], tab)) {
+                    results.rootDirSize = maxRootEntries * 0x20;
+                    updateResultItem('rootDirSize1216', results.rootDirSize, true,
+                        `0x${maxRootEntries.toString(16)} × 0x20 = 0x${results.rootDirSize.toString(16)}`);
+                } else {
+                    updateResultItem('rootDirSize1216', 0, false);
+                }
+
+                if (results.fatEnd !== undefined) {
+                    results.rootDirStart = results.fatEnd;
+                    updateResultItem('rootDirStart1216', results.rootDirStart, true,
+                        `0x${results.fatEnd.toString(16)}`);
+                } else {
+                    updateResultItem('rootDirStart1216', 0, false);
+                }
+
+                // Data Start for FAT12/16
+                if (results.fatEnd !== undefined && results.rootDirSize !== undefined) {
+                    results.dataStart = results.fatEnd + results.rootDirSize;
+                    results.dataStartSector = Math.floor(results.dataStart / sectorSize);
+                    updateResultItem('dataStart1216', results.dataStart, true,
+                        `0x${results.fatEnd.toString(16)} + 0x${results.rootDirSize.toString(16)} = 0x${results.dataStart.toString(16)}`);
+                    updateResultItem('dataStartSector1216', results.dataStartSector, true,
+                        `0x${results.dataStart.toString(16)} ÷ 0x${sectorSize.toString(16)} = 0x${results.dataStartSector.toString(16)}`);
+                } else {
+                    updateResultItem('dataStart1216', 0, false);
+                    updateResultItem('dataStartSector1216', 0, false);
+                }
+            } else {
+                // Data Start for FAT32 (no fixed root directory)
+                if (results.fatEnd !== undefined) {
+                    results.dataStart = results.fatEnd;
+                    results.dataStartSector = Math.floor(results.dataStart / sectorSize);
+                    updateResultItem('dataStart32', results.dataStart, true,
+                        `0x${results.fatEnd.toString(16)}`);
+                    updateResultItem('dataStartSector32', results.dataStartSector, true,
+                        `0x${results.dataStart.toString(16)} ÷ 0x${sectorSize.toString(16)} = 0x${results.dataStartSector.toString(16)}`);
+                } else {
+                    updateResultItem('dataStart32', 0, false);
+                    updateResultItem('dataStartSector32', 0, false);
+                }
+            }
+
+            // Data Size
+            const requiredForDataSize = tab === 'fat1216' 
+                ? [`partitionSizeInSectors${suffix}`, `sectorSize1216`, `reservedSectors${suffix}`, `baseOffset1216`, `numFATs${suffix}`, `fatSizeSectors${suffix}`, 'maxRootEntries1216']
+                : [`partitionSizeInSectors${suffix}`, `sectorSize32`, `reservedSectors${suffix}`, `baseOffset32`, `numFATs${suffix}`, `fatSizeSectors${suffix}`];
+
+            if (checkDependencies(requiredForDataSize, tab) && results.dataStart !== undefined) {
+                const partitionSizeBytes = partitionSizeInSectors * sectorSize;
+                results.dataSize = partitionSizeBytes - (results.dataStart - baseOffset);
+                updateResultItem(`dataSize${suffix}`, results.dataSize, true,
+                    `(0x${partitionSizeInSectors.toString(16)} × 0x${sectorSize.toString(16)}) - (0x${results.dataStart.toString(16)} - 0x${baseOffset.toString(16)}) = 0x${results.dataSize.toString(16)}`);
+            } else {
+                updateResultItem(`dataSize${suffix}`, 0, false);
+            }
+
+            // Cluster Size
+            if (checkDependencies([`sectorSize${suffix === '32' ? '32' : '1216'}`, `clusterSizeSectors${suffix}`], tab)) {
+                results.clusterSize = sectorSize * clusterSizeSectors;
+                updateResultItem(`clusterSize${suffix}`, results.clusterSize, true,
+                    `0x${sectorSize.toString(16)} × 0x${clusterSizeSectors.toString(16)} = 0x${results.clusterSize.toString(16)}`);
+            } else {
+                updateResultItem(`clusterSize${suffix}`, 0, false);
+            }
+
+            // Number of Clusters
+            if (results.dataSize !== undefined && results.clusterSize !== undefined && results.clusterSize > 0) {
+                results.numClusters = Math.floor(results.dataSize / results.clusterSize);
+                updateResultItem(`numClusters${suffix}`, results.numClusters, true,
+                    `0x${results.dataSize.toString(16)} ÷ 0x${results.clusterSize.toString(16)} = 0x${results.numClusters.toString(16)}`);
+            } else {
+                updateResultItem(`numClusters${suffix}`, 0, false);
+            }
+
+            // Specific Cluster Start
+            const requiredForCluster = tab === 'fat1216'
+                ? [`reservedSectors${suffix}`, `sectorSize1216`, `baseOffset1216`, `numFATs${suffix}`, `fatSizeSectors${suffix}`, 'maxRootEntries1216', `clusterSizeSectors${suffix}`, `clusterNumber${suffix}`]
+                : [`reservedSectors${suffix}`, `sectorSize32`, `baseOffset32`, `numFATs${suffix}`, `fatSizeSectors${suffix}`, `clusterSizeSectors${suffix}`, `clusterNumber${suffix}`];
+
+            if (checkDependencies(requiredForCluster, tab) && results.dataStart !== undefined && results.clusterSize !== undefined) {
+                results.clusterStart = results.dataStart + (clusterNumber - 0x2) * results.clusterSize;
+                results.clusterStartSector = Math.floor(results.clusterStart / sectorSize);
+                updateResultItem(`clusterStart${suffix}`, results.clusterStart, true,
+                    `0x${results.dataStart.toString(16)} + (0x${clusterNumber.toString(16)} - 0x2) × 0x${results.clusterSize.toString(16)} = 0x${results.clusterStart.toString(16)}`);
+                updateResultItem(`clusterStartSector${suffix}`, results.clusterStartSector, true,
+                    `0x${results.clusterStart.toString(16)} ÷ 0x${sectorSize.toString(16)} = 0x${results.clusterStartSector.toString(16)}`);
+            } else {
+                updateResultItem(`clusterStart${suffix}`, 0, false);
+                updateResultItem(`clusterStartSector${suffix}`, 0, false);
+            }
+
+            // FAT Entry Position
+            if (checkDependencies([`reservedSectors${suffix}`, `sectorSize${suffix === '32' ? '32' : '1216'}`, `baseOffset${suffix === '32' ? '32' : '1216'}`, `clusterNumber${suffix}`], tab) && results.fatStart !== undefined) {
+                const entrySize = tab === 'fat32' ? 4 : 2; // FAT32 uses 4 bytes, FAT16 uses 2 bytes per entry
+                results.fatEntryPos = results.fatStart + (clusterNumber * entrySize);
+                updateResultItem(`fatEntryPos${suffix}`, results.fatEntryPos, true,
+                    `0x${results.fatStart.toString(16)} + (0x${clusterNumber.toString(16)} × ${entrySize}) = 0x${results.fatEntryPos.toString(16)}`);
+            } else {
+                updateResultItem(`fatEntryPos${suffix}`, 0, false);
+            }
+
+            // Root Directory Position (FAT32 only)
+            if (tab === 'fat32') {
+                const requiredForRootPos = [`reservedSectors${suffix}`, `sectorSize32`, `baseOffset32`, `numFATs${suffix}`, `fatSizeSectors${suffix}`, `clusterSizeSectors${suffix}`, `rootDirCluster32`];
+                if (checkDependencies(requiredForRootPos, tab) && results.dataStart !== undefined && results.clusterSize !== undefined) {
+                    results.rootDirPos = results.dataStart + (rootDirCluster - 0x2) * results.clusterSize;
+                    updateResultItem('rootDirPos32', results.rootDirPos, true,
+                        `0x${results.dataStart.toString(16)} + (0x${rootDirCluster.toString(16)} - 0x2) × 0x${results.clusterSize.toString(16)} = 0x${results.rootDirPos.toString(16)}`);
+                } else {
+                    updateResultItem('rootDirPos32', 0, false);
+                }
+            }
+        }
+
+        // Tooltip functions
         function createTooltip() {
             if (!tooltip) {
                 tooltip = document.createElement('div');
@@ -1375,7 +1514,6 @@
             }
         }
 
-        // Show tooltip
         function showTooltip(element, text) {
             createTooltip();
             tooltip.innerHTML = text;
@@ -1387,7 +1525,6 @@
             let left = rect.left + (rect.width / 2) - (tooltipRect.width / 2);
             let top = rect.top - tooltipRect.height - 8;
 
-            // Keep tooltip within viewport
             if (left < 10) left = 10;
             if (left + tooltipRect.width > window.innerWidth - 10) {
                 left = window.innerWidth - tooltipRect.width - 10;
@@ -1400,120 +1537,12 @@
             tooltip.style.top = top + 'px';
         }
 
-        // Hide tooltip
         function hideTooltip() {
             if (tooltip) {
                 tooltip.style.display = 'none';
             }
         }
 
-        // Filesystem calculation implementations
-        const filesystems = {
-            fat1216: {
-                requiredFields: ['reservedSectors1216', 'numFATs1216', 'fatSizeSectors1216', 'maxRootEntries1216', 'partitionSizeInSectors1216', 'clusterSizeSectors1216'],
-                calculate: function () {
-                    const baseOffset = parseHex(document.getElementById('baseOffset1216').value);
-                    const sectorSize = parseHex(document.getElementById('sectorSize1216').value);
-                    const reservedSectors = parseHex(document.getElementById('reservedSectors1216').value);
-                    const numFATs = parseHex(document.getElementById('numFATs1216').value);
-                    const fatSizeSectors = parseHex(document.getElementById('fatSizeSectors1216').value);
-                    const maxRootEntries = parseHex(document.getElementById('maxRootEntries1216').value);
-                    const partitionSizeInSectors = parseHex(document.getElementById('partitionSizeInSectors1216').value);
-                    const clusterSizeSectors = parseHex(document.getElementById('clusterSizeSectors1216').value);
-                    const clusterNumber = parseHex(document.getElementById('clusterNumber1216').value);
-
-                    const fatStart = reservedSectors * sectorSize + baseOffset;
-                    const fatSize = numFATs * fatSizeSectors * sectorSize;
-                    const fatEnd = fatStart + fatSize;
-                    const rootDirStart = fatEnd;
-                    const rootDirSize = maxRootEntries * 0x20;
-                    const dataStart = fatEnd + rootDirSize;
-                    const partitionSizeBytes = partitionSizeInSectors * sectorSize;
-                    const dataSize = partitionSizeBytes - (dataStart - baseOffset);
-                    const clusterSize = sectorSize * clusterSizeSectors;
-                    const numClusters = clusterSize > 0 ? Math.floor(dataSize / clusterSize) : 0;
-                    const clusterStart = dataStart + (clusterNumber - 0x2) * clusterSize;
-
-                    const calculations = {
-                        fatStart: `0x${reservedSectors.toString(16)} × 0x${sectorSize.toString(16)} + 0x${baseOffset.toString(16)} = 0x${fatStart.toString(16)}`,
-                        fatSize: `0x${numFATs.toString(16)} × 0x${fatSizeSectors.toString(16)} * 0x${sectorSize.toString(16)}= 0x${fatSize.toString(16)}`,
-                        fatEnd: `0x${fatStart.toString(16)} + 0x${fatSize.toString(16)} = 0x${fatEnd.toString(16)}`,
-                        rootDirStart: `0x${fatEnd.toString(16)}`,
-                        rootDirSize: `0x${maxRootEntries.toString(16)} × 0x20 = 0x${rootDirSize.toString(16)}`,
-                        dataStart: `0x${fatEnd.toString(16)} + 0x${rootDirSize.toString(16)} = 0x${dataStart.toString(16)}`,
-                        dataSize: `(0x${partitionSizeInSectors.toString(16)} × 0x${sectorSize.toString(16)}) - (0x${dataStart.toString(16)} - 0x${baseOffset.toString(16)}) = 0x${dataSize.toString(16)}`,
-                        clusterSize: `0x${sectorSize.toString(16)} × 0x${clusterSizeSectors.toString(16)} = 0x${clusterSize.toString(16)}`,
-                        numClusters: `0x${dataSize.toString(16)} ÷ 0x${clusterSize.toString(16)} = 0x${numClusters.toString(16)}`,
-                        clusterStart: `0x${dataStart.toString(16)} + (0x${clusterNumber.toString(16)} - 0x2) × 0x${clusterSize.toString(16)} = 0x${clusterStart.toString(16)}`
-                    };
-
-                    return {
-                        fatStart, fatSize, fatEnd, rootDirStart, rootDirSize, dataStart, dataSize,
-                        clusterSize, numClusters, clusterStart, calculations
-                    };
-                }
-            },
-            fat32: {
-                requiredFields: ['reservedSectors32', 'numFATs32', 'fatSizeSectors32', 'rootDirCluster32', 'partitionSizeInSectors32', 'clusterSizeSectors32'],
-                calculate: function () {
-                    const baseOffset = parseHex(document.getElementById('baseOffset32').value);
-                    const sectorSize = parseHex(document.getElementById('sectorSize32').value);
-                    const reservedSectors = parseHex(document.getElementById('reservedSectors32').value);
-                    const numFATs = parseHex(document.getElementById('numFATs32').value);
-                    const fatSizeSectors = parseHex(document.getElementById('fatSizeSectors32').value);
-                    const rootDirCluster = parseHex(document.getElementById('rootDirCluster32').value);
-                    const partitionSizeInSectors = parseHex(document.getElementById('partitionSizeInSectors32').value);
-                    const clusterSizeSectors = parseHex(document.getElementById('clusterSizeSectors32').value);
-                    const clusterNumber = parseHex(document.getElementById('clusterNumber32').value);
-
-                    const fatStart = reservedSectors * sectorSize + baseOffset;
-                    const fatSize = numFATs * fatSizeSectors * sectorSize;
-                    const fatEnd = fatStart + fatSize;
-                    const dataStart = fatEnd;
-                    const partitionSizeBytes = partitionSizeInSectors * sectorSize;
-                    const dataSize = partitionSizeBytes - (dataStart - baseOffset);
-                    const clusterSize = sectorSize * clusterSizeSectors;
-                    const numClusters = clusterSize > 0 ? Math.floor(dataSize / clusterSize) : 0;
-                    const clusterStart = dataStart + (clusterNumber - 0x2) * clusterSize;
-                    const rootDirPos = dataStart + (rootDirCluster - 0x2) * clusterSize;
-
-                    const calculations = {
-                        fatStart: `0x${reservedSectors.toString(16)} × 0x${sectorSize.toString(16)} + 0x${baseOffset.toString(16)} = 0x${fatStart.toString(16)}`,
-                        fatSize: `0x${numFATs.toString(16)} × 0x${fatSizeSectors.toString(16)} * 0x${sectorSize.toString(16)}= 0x${fatSize.toString(16)}`,
-                        fatEnd: `0x${fatStart.toString(16)} + 0x${fatSize.toString(16)} = 0x${fatEnd.toString(16)}`,
-                        dataStart: `0x${fatEnd.toString(16)}`,
-                        dataSize: `(0x${partitionSizeInSectors.toString(16)} × 0x${sectorSize.toString(16)}) - (0x${dataStart.toString(16)} - 0x${baseOffset.toString(16)}) = 0x${dataSize.toString(16)}`,
-                        clusterSize: `0x${sectorSize.toString(16)} × 0x${clusterSizeSectors.toString(16)} = 0x${clusterSize.toString(16)}`,
-                        numClusters: `0x${dataSize.toString(16)} ÷ 0x${clusterSize.toString(16)} = 0x${numClusters.toString(16)}`,
-                        clusterStart: `0x${dataStart.toString(16)} + (0x${clusterNumber.toString(16)} - 0x2) × 0x${clusterSize.toString(16)} = 0x${clusterStart.toString(16)}`,
-                        rootDirPos: `0x${dataStart.toString(16)} + (0x${rootDirCluster.toString(16)} - 0x2) × 0x${clusterSize.toString(16)} = 0x${rootDirPos.toString(16)}`
-                    };
-
-                    return {
-                        fatStart, fatSize, fatEnd, dataStart, dataSize,
-                        clusterSize, numClusters, clusterStart, rootDirPos, calculations
-                    };
-                }
-            }
-        };
-
-        function parseHex(value) {
-            if (!value) return 0;
-            let cleanValue = value.toString().trim();
-            if (cleanValue.startsWith('0x') || cleanValue.startsWith('0X')) {
-                cleanValue = cleanValue.substring(2);
-            }
-            const parsed = parseInt(cleanValue, 16);
-            return isNaN(parsed) ? 0 : Math.max(0, parsed);
-        }
-
-        function formatHex(value) {
-            if (isNaN(value) || value < 0) {
-                return '<span class="error">Fehler</span>';
-            }
-            return '0x' + Math.floor(value).toString(16).toUpperCase();
-        }
-
         function copyToClipboard(elementId) {
             const element = document.getElementById(elementId);
             const text = element.textContent.trim();
@@ -1532,7 +1561,7 @@
                     btn.style.color = '';
                 }, 1000);
             }).catch(err => {
-                console.error('Failed to copy to clipboard:', err);
+                console.error('Fehler beim Kopieren:', err);
             });
         }
 
@@ -1548,200 +1577,67 @@
             document.getElementById(tabId).classList.add('active');
             event.target.classList.add('active');
 
-            // Update calculator display when switching tabs
-            updateCalculatorDisplay(tabId);
+            updateCalculatorDisplay();
         }
 
-        function calculate(fsType) {
-            try {
-                const fs = filesystems[fsType];
-                if (!fs) {
-                    alert('Unknown filesystem type: ' + fsType);
-                    return;
-                }
-
-                const results = fs.calculate();
-
-                if (fsType === 'fat1216') {
-                    const mapping = {
-                        'fatStart1216': ['fatStart', 'fatStart'],
-                        'fatSize1216': ['fatSize', 'fatSize'],
-                        'fatEnd1216': ['fatEnd', 'fatEnd'],
-                        'rootDirStart1216': ['rootDirStart', 'rootDirStart'],
-                        'rootDirSize1216': ['rootDirSize', 'rootDirSize'],
-                        'dataStart1216': ['dataStart', 'dataStart'],
-                        'dataSize1216': ['dataSize', 'dataSize'],
-                        'clusterSize1216': ['clusterSize', 'clusterSize'],
-                        'numClusters1216': ['numClusters', 'numClusters'],
-                        'clusterStart1216': ['clusterStart', 'clusterStart']
-                    };
-                    Object.entries(mapping).forEach(([elementId, [resultKey, calcKey]]) => {
-                        const element = document.getElementById(elementId);
-                        element.innerHTML = formatHex(results[resultKey]);
-                        element.setAttribute('data-result-formula', results.calculations[calcKey]);
-                    });
-                } else if (fsType === 'fat32') {
-                    const mapping = {
-                        'fatStart32': ['fatStart', 'fatStart'],
-                        'fatSize32': ['fatSize', 'fatSize'],
-                        'fatEnd32': ['fatEnd', 'fatEnd'],
-                        'dataStart32': ['dataStart', 'dataStart'],
-                        'dataSize32': ['dataSize', 'dataSize'],
-                        'clusterSize32': ['clusterSize', 'clusterSize'],
-                        'numClusters32': ['numClusters', 'numClusters'],
-                        'clusterStart32': ['clusterStart', 'clusterStart'],
-                        'rootDirPos32': ['rootDirPos', 'rootDirPos']
-                    };
-
-                    Object.entries(mapping).forEach(([elementId, [resultKey, calcKey]]) => {
-                        const element = document.getElementById(elementId);
-                        element.innerHTML = formatHex(results[resultKey]);
-                        element.setAttribute('data-result-formula', results.calculations[calcKey]);
-                    });
-                }
-
-            } catch (error) {
-                alert('Fehler bei der Berechnung: ' + error.message);
-                console.error('Calculation error:', error);
-            }
-        }
-
-        // Add event listeners
+        // Event listeners
         document.addEventListener('DOMContentLoaded', function () {
-            // Initialize calculator displays
-            updateCalculatorDisplay('fat1216');
-            updateCalculatorDisplay('fat32');
+            updateCalculatorDisplay();
 
-            // Real-time calculation for required fields
-            Object.keys(filesystems).forEach(fsType => {
-                const fs = filesystems[fsType];
-                fs.requiredFields.forEach(fieldId => {
-                    const input = document.getElementById(fieldId);
-                    if (input) {
-                        input.addEventListener('input', function () {
-                            const allFilled = fs.requiredFields.every(id =>
-                                document.getElementById(id).value.trim() !== ''
-                            );
-                            if (allFilled) {
-                                calculate(fsType);
-                            }
-                        });
-                    }
+            // Input validation and calculation triggers
+            const allInputs = document.querySelectorAll('input[type="text"]:not([readonly])');
+            allInputs.forEach(input => {
+                input.addEventListener('input', function () {
+                    const currentTab = getCurrentTab();
+                    validateInput(this.id, this.value);
+                    calculateValues(currentTab);
                 });
             });
 
-            // Real-time calculation for constants fields
-            ['baseOffset1216', 'sectorSize1216'].forEach(fieldId => {
-                const input = document.getElementById(fieldId);
-                if (input) {
-                    input.addEventListener('input', function () {
-                        const fs = filesystems.fat1216;
-                        const allFilled = fs.requiredFields.every(id =>
-                            document.getElementById(id).value.trim() !== ''
-                        );
-                        if (allFilled) {
-                            calculate('fat1216');
-                        }
-                    });
-                }
-            });
-
-            ['baseOffset32', 'sectorSize32'].forEach(fieldId => {
-                const input = document.getElementById(fieldId);
-                if (input) {
-                    input.addEventListener('input', function () {
-                        const fs = filesystems.fat32;
-                        const allFilled = fs.requiredFields.every(id =>
-                            document.getElementById(id).value.trim() !== ''
-                        );
-                        if (allFilled) {
-                            calculate('fat32');
-                        }
-                    });
-                }
-            });
-
-            // Add separate listeners for cluster number fields
-            ['clusterNumber1216', 'clusterNumber32'].forEach(fieldId => {
-                const input = document.getElementById(fieldId);
-                if (input) {
-                    input.addEventListener('input', function () {
-                        const fsType = fieldId.includes('32') ? 'fat32' : 'fat1216';
-                        const fs = filesystems[fsType];
-                        const allFilled = fs.requiredFields.every(id =>
-                            document.getElementById(id).value.trim() !== ''
-                        );
-                        if (allFilled) {
-                            calculate(fsType);
-                        }
-                    });
-                }
-            });
-
-            // Keyboard input support for calculator
+            // Keyboard support for calculator
             document.addEventListener('keydown', function (e) {
-                // Only handle keyboard input when not in an input field
-                if (e.target.tagName === 'INPUT') return;
+                if (e.target.tagName === 'INPUT' && !e.target.readOnly) return;
 
-                const currentTab = getCurrentTab();
                 const key = e.key.toUpperCase();
 
-                // Handle hex digits
                 if (/^[0-9A-F]$/.test(key)) {
                     e.preventDefault();
-                    calcInput(key, currentTab);
-                }
-                // Handle operations
-                else if (key === '+') {
+                    calcInput(key);
+                } else if (key === '+') {
                     e.preventDefault();
-                    calcOperation('+', currentTab);
-                }
-                else if (key === '-') {
+                    calcOperation('+');
+                } else if (key === '-') {
                     e.preventDefault();
-                    calcOperation('-', currentTab);
-                }
-                else if (key === '*') {
+                    calcOperation('-');
+                } else if (key === '*') {
                     e.preventDefault();
-                    calcOperation('*', currentTab);
-                }
-                else if (key === '/') {
+                    calcOperation('*');
+                } else if (key === '/') {
                     e.preventDefault();
-                    calcOperation('/', currentTab);
-                }
-                else if (key === 'ENTER' || key === '=') {
+                    calcOperation('/');
+                } else if (key === 'ENTER' || key === '=') {
                     e.preventDefault();
-                    calcEquals(currentTab);
-                }
-                else if (key === 'ESCAPE' || key === 'C') {
+                    calcEquals();
+                } else if (key === 'ESCAPE' || key === 'C') {
                     e.preventDefault();
-                    calcClear(currentTab);
-                }
-                else if (key === 'BACKSPACE') {
+                    calcClear();
+                } else if (key === 'BACKSPACE') {
                     e.preventDefault();
-                    calcBackspace(currentTab);
-                }
-                // Handle shift operations
-                else if (e.shiftKey && key === ',') { // < key
-                    e.preventDefault();
-                    calcOperation('<<', currentTab);
-                }
-                else if (e.shiftKey && key === '.') { // > key
-                    e.preventDefault();
-                    calcOperation('>>', currentTab);
+                    calcBackspace();
                 }
             });
 
-            // Tooltip event listeners
+            // Tooltip events
             document.addEventListener('mouseover', function (e) {
                 if (e.target.classList.contains('result-label')) {
                     const formula = e.target.getAttribute('data-formula');
                     if (formula) {
-                        showTooltip(e.target, `Formula: ${formula}`);
+                        showTooltip(e.target, `Formel: ${formula}`);
                     }
                 } else if (e.target.classList.contains('result-value')) {
                     const formula = e.target.getAttribute('data-result-formula');
                     if (formula && formula !== '') {
-                        showTooltip(e.target, `Calculation: ${formula}`);
+                        showTooltip(e.target, `Berechnung: ${formula}`);
                     }
                 }
             });
@@ -1752,8 +1648,11 @@
                 }
             });
 
-            // Hide tooltip when scrolling
             document.addEventListener('scroll', hideTooltip);
+
+            // Initial calculation
+            calculateValues('fat1216');
+            calculateValues('fat32');
         });
     </script>
 </body>
