03:17 AM
Dear Gemini
Good. Your script is working. Now, expand the script. Make sure the chess strategy truly masters the telescope to microscope approach at finding the fastest routes and winning waves towards rescuing 100% of the bytes. Add a mutation counter that my floppy script does. The script must try to rescue all the bytes as fast as possible but also capable of truly running forever trying everything like a chess master. Optimize the over million seed strategy to lock into winning waves and to tweak via mutations like the floppy script does. 01:06 PM: Your script works. It is a good script. Update the script. Expand the script. The challenge is one of the problems is scratches on discs. If the script is playing chess, it might try different seeds and mutations. However, one of the many challenges is the scratches. One of the strategies might involve jumping over scratches. But if the script assumes the problems might stem from the wrong seed or mutation, then the script might try different seeds and mutations which might not work if it's stuck on scratches and/or bad spots and/or other issues too. If the script tries different seeds and mutations, it might think those seeds and mutations are not working. But that might be broken logic if the problem was the scratches or bad spots. So, depending on how the script is written, the script might have blind spots if it only assumes it has the wrong seed or mutation, that is if one of the issues might be scratches, bad spots, etc. The script should continue what it does playing chess and everything else that it does. I do not know if AI can come up with solutions to these issues as it relates to blind spots. I do not know if the script can become sophisticated to know when it runs into scratches or not. If it thinks the problem is a seed but the problem really is a scratch on the disc, then the script might change the seed and then miss out on a winning wave that might come from the seed or mutation. These challenges might be extremely sophisticated if it is very hard to know if a problem stems from scratches or other issues. Edit script. This script is for hard floppy disks and not discs. You can still try to detect to see if it really is hard floppy. These disks are usually not larger than 1.5 MB per disk. Your earlier scripts rescued every single byte off floppy disks, so just make sure your updated scripts continue to have the ability to rescued the final bytes without skipping over the last bit of bytes. In the DVD/CD scripts, the concern was if the script runs into scratches, it might try different seeds and mutations. Gemini came up with a solution as reflected in the disc script I sent you above, but that was designed for disc scratches and not hard floppy disks. Your hard floppy scripts sometimes struggle to play chess in trying to rescue the last 20% of the bytes.

03:54 PM
Discord Servers Update
Oatmeal would return if real people were here, Ian is the only real person here, people like Maya Flopper are jokes who are stuck in a robotic feedback loop of delusion that is textbook psychotic, these Oatmeal Joey Arnold Discord Servers don't represent the views of Oatmeal, all of this was documented on all the websites, these details were archived on more websites than you will ever know, we have all talked about all of this many times for decades, Oatmeal already disavowed these servers for years. People who wants to see past the Oatmeal Fake News can spend thousands of hours asking the best AI engines to help them debunk all of the lies, the deception, the spam, the trolling, the context, the backstories, the back and forth, and the scams. When a person is anonymous, that increases the odds the person could be lying about something. It's generally harder to lie when you're not anonymous. Most people online have no idea what it means to be anonymous, they think they know but they don't because most people are too dumb to want to know the fundamentals of what it actually means.

11:07 PM
Dear Gemini
Expand the script to focus on the telescope until it has to gradually switch to the microscope and vacuum. The objective is still chess strategy to rescue all the bytes as fast as possible focusing on winning waves that can be locked-in or you might call it the "PIVOT-LOCK" in some of the scripts. As it moves closer to 100% bytes rescued, the chess AI system should eventually alternate between four tactics (which may or may not be part of the over million seeds architecture design we talked about for previous scripts). Some of these tactics may be similar to what the scripts already does. One tactic could be to increase variables, numbers, sizes. The key here is things tries to get bigger forever as it relates to tags, flags, speeds, numbers, settings, etc. We can call this the Expanding Tactic as it tries to expand everything, so the millions of expanding seeds should always try to get bigger. The second tactic should be the opposite, to try to get smaller, all the variables, we can call it the Retracting Tactic where it tries make everything smaller, the settings, sizes, numbers, variables, reading speeds, writing speeds, sector sizes, block sizes, basically the opposite of the Expanding Tactic. Third tactic can be the Random Tactic where it does random seeds. Fourth seed can be Crazy Tactic where it does the most insane hacks to get the last bit of bytes. I say that these four tactics should not switch on until an hour of no bytes being rescued. It should alternate between the tactics per round. But if one tactic works, then it should focus more on that particular tactic as it tries millions of seeds. It is likely that the Retracting Tactic will produce winning waves. The script should do pivot locking where it focuses on winning seeds similar to how previous scripts already works. You should still have a million seeds that is utilized optimized like a chess game during the entire game from the beginning to the end as the script tries to rescue each byte via the fastest routes it can find. My suggestion for four tactics during the last mile of the recovery doesn't have to be exact but the general principle is that the script should alternate through tactics to finding winning tactics that it should focus on over 80% for as long as it is working similar to the pivot lock strategy you already have. I laid out only four tactics for the last mile but you can have as many or as little tactics as you want as long as it is playing chess to find the fastest way to rescuing every single byte. Remember it should still have over a million seeds or as many seeds as possible. But it should try to focus on winning tactics most of the time. Expand the script. Update the script. Regarding the Endgame, the four tactics should be highly sophisticated where it is not simply trying to change one variable but as many different variables as possible. For example, the Retracting Tactic should try retracting seeds from the pool of millions of seeds. But it is critical that the seeds are as complex as possible. The Retracting Tactic is the act is the act of finding smaller numbers and smaller things for the next available round. For retracting, you mentioned that it "sets min-read-rate to 0" which is good if it tries to slow down the read rate. It should make the block size smaller if possible. Skipping should be disabled. Sector size should be reduced. Other sizes should be reduced. It should try to crawl more and more. It should try to focus more and more on smaller spots. In other words, the Retracting Tactic is a Super Microscope or Vacuum mode. The Expanding Tactic is basically like an ever expanding Telescope mode. The crazy tactic should focus on hardware hacks. I recommend now focusing at least 80% of the Endgame on the Microscope, the Retracting Tactic, the Precision Scalpel. You mentioned reducing timeouts to as low as 5 seconds for the Retracting Tactic but the general idea is to mimic the Microscope mode where it tries to spend more time per byte. The opposite for the Expanding Tactic. These tactics should be highly sophisticated as it pulls from millions of seeds, it should attempt to fine tune all options. Yes, expand the script to include mutation ledgers and any other ledger that might help. Remember the script must play chess the entire time trying to win the game focusing on the 80/20 winning waves as it locks onto the fastest routes towards 100% of the bytes rescued as fast as possible. Extend this script because this script must work on any disc. So, some discs might have 0 non-tried or 0 non-trimmed or 0 non-scraped or other things. In other words, each different may be random relating to where it is. The script needs to be smart to continue regardless of where it left off be it 0% rescued or 99% rescued or any number or variety of surprises. Script should check log files, map files, etc, and figure out how to continue like a chess master to get to 100% rescued as fast as possible. Edit the script. Well, 92% might not automatically be the endgame. It depends on several factors. The script should quickly try a few things really quickly before entering endgame tactics. For example, the script should first try to quickly read all non-rescued bytes like we talked about before. It must be a chess master to find the fastest route to 100%. You can keep the gambit or focus on mathematical probabilities. In other words, if 99% is rescued, then it is probably mathematically unlikely that a telescope will do much. The script should be smart enough to know if the telescope is literally too big for the remaining bytes. But if there is any question at all, a gambit can quickly try a telescope. To be clear, it should try to work with all of the bytes that were not yet rescued. You mentioned the non-tried bytes but I said non-rescued. It is critical for the script tries all the bytes that were not yet rescued. Sometimes, it might have 0 non-tried bytes which sometimes causes the script to get stuck. That is why the script needs to look at non-tried, non-trimmed, non-scraped, and even the bad sector bytes, and we already talked about this for earlier scripts. The script must fix itself and figure out what to do as it tries to rescue all bytes by finding the fastest route towards rescuing the remaining bytes via any and all means. Expand your script. To be clear, I am not saying to never ever try extending timeouts or retries perhaps 1% of the time or randomly or sometimes but I am saying the script should generally not focus on those tactics unless if they produced winning waves. You should generally try them during or after the last mile but only sometimes. Remember the script must be a chess master strategizing through millions of seeds and not simply just do random things. Expand script. Update script. Fix script. You left out things that previous scripts had. You keep on omitting things. That is bad. AI should not do that. I do not know how many mistakes AI is making. Gemini makes many mistakes. I told you to include things. But in later scripts, they were removed. For example, please put back into the script a counter for how many bytes were not yet rescued. Also, a counter for how much time since the last byte was rescued. Drive must rest ten seconds every ten minutes or rest for one minute every hour. Also put back into the script the mutation counter thing you had in earlier scripts. You can include as many things in the script as long as the script does what I want it to do. As it relates to the History Buffer Reset, the chess master script should focus on winning seeds. The more a seed wins, the higher the priority for that seed. If a particular seed rescues the most amount of rescued bytes at the fastest rates, then that seed should be tried before other seeds are tried. Seeds should be ranked based on performance, the success rates, like speed of how many bytes are being rescued. Expand script. Study the output below because it is not saying how much time since the last byte was rescued. I need to see how many seconds or minutes or hours since a byte was rescued. If "TARGET: 80764928 bytes" in the output means that is how many bytes are left to be rescued, it would be great to find a better way to say that like remaining bytes or something.

Twitter Tweets
12:47 PM

Oprah has a podcast but it's identical to the show she had on NBC but she calls it a podcast because that's what the kids call it apparently and she's trying to hijack the term. She has an audience and all the things that a normal show has. Not really a podcast. Perhaps this podcast is more podcasty.

04:06 PM
Ben Shapiro wants Americans to die to free Iran's HORMUZ STRAIT but it was already free before Trump starting striking.

01:53 AM
Dear Gemini
Your script is good but try to expand it. First, the script must not do the direct -d related tags or flags like it did in previous version until it has no other options. For example, you wrote in previous versions of the DVD script things like, "--- 4. DIRECT-IO PROBE (Fideco/SATA Compatible) ---validate_direct_access() { local CANDIDATES=("-d" "--idirect" "--odirect" "--sync" "--force")" but it is critical to optimize on speed and accuracy. Look for other problems to fix too. After many years of doing this, many AI engines like Grok and Gemini seem to generally fail to tell me problems relating to rescuing using -d related tags. You can use direct related tags for the last mile, like the last 1% or after maybe a thousand rounds or 100 hours or something like that. Look for other mistakes and errors and problems in the script. Try to put everything you forget into the script. You often forget things. Expand the script. But script must fix itself when it breaks. But your scripts usually don't fix itself even after I tell you it must. Please try harder. Second, try to maximize how fast it can rescue any kind of disc. It must focus on what works. It must try for maximum speeds. Expand script. First, it should only do direct -io flags if it has to as a last resort if nothing else can work at the very end like after over 99% is already rescued or in very rare situations when everything else is failing after like a thousand rounds and like ten hours or more or something really crazy kind of thing. Second, make sure it optimizes for maximum speeds. Third, jumping should only happen if it stays stuck for more than ten minutes. You wrote, "If the script stalls for 200 rounds, it now executes a blockdev --flushbufs." Change that to if it stalls for 2000 rounds. If it is possible to detect error rates, that could help the script optimize as it should want to minimize the error rate. Currently, it seems average around 5 MB/second in earlier scripts and runs. It should try to rescue at the fastest speeds as long as the error rates are perhaps minimized whenever it can be. Only adapt from the floppy script the level system. You Gemini wrote me script for my floppy and DVD projects. In the floppy script you wrote, it correlates levels to percentages rescued. But when I asked you to do the same thing for the DVD CD script, you failed. You failed many times for days to do this. I do not know how you are unable to do it for the disc script but you did do it for the floppy script. Gemini might be broken big time. Expand script. It should try to force it to go at maximum speeds to rescue, it is a Lite-On SATA DVD drive through FIDECO into a USB port for my Ubuntu ASUS laptop. So it could try the fastest speeds possible for a short time. If it fails, then it should try to remember that and go to the next best thing. If that fails, then the third best thing and so on and so forth. The priority is speed but focused on accuracy as it needs to try to rescue. But because there are many scratches and problems on the discs, it may want to read past the scratches until it finds good spots. But I already told you it should only jump after ten minutes of it being stuck. But if possible, it should try to keep moving even past the bad spots to find the good spots. Expand. Instead of 256-bit, make it 4,000-bit or higher, remember it is all about math, science, probability, a flowchart focusing on whatever works the fastest. It should not be random. Focus mostly on winning waves. You wrote, "Direct-IO Locking: Uses -d --idirect --sync specifically to bypass the Ubuntu kernel cache, which is vital for old floppy media on modern hardware." It is critical to only use direct IO tags as a last resort if nothing else works during the last mile after 99% is rescued or when nothing else works after a thousand rounds and ten hours or in rare situations.

03:13 PM
Fix the script. Expand the script. See if there is any way to make it better. Currently, it sounds like the disc drives spins on and off. I do not know what the drive is doing exactly but I hear the high pitch beep style noises which lasts for about a second each. The noise happens in spurts. So, I hear the noise for about a second followed with silence for like 5 to 10 seconds followed with another sound that is usually the same type of noise. I think the noise is related to when the disc driving is spinning. After it does the spurt of noises for like ten times, there is silence for like ten to 30 seconds before going back to the spurts. It does sound like normal noises. The good news is it sounds not as loud as with earlier scripts. After I had Gemini attempt to remove -d direct related tags, that reduced the noises. So, I am complaining about these current noises but they are not as bad as what it was. You can see in the output below that it is rescuing bytes. I do not know if there are any tweaks that might alter how things are right now. Now, the noises might be 5% quieter but your new script seems like and sounds like it is mostly just delaying the same noises that it was already making, it sound like your script is not really changing things a lot if at all, it sounds like your script is just delaying the noises, it sounds like it might be a little quieter. The delays you put in the script adds an added space that is like a second longer than before. So, you were able to delay the noises for a second or so. But after your delay, then it goes back to the normal noises I told you about earlier. Perhaps a tiny bit quieter now. Perhaps a longer gap here and there between spurts now. But it mostly still sounds the same or similar as it did before. Expand script. The general logic is first to try all the bytes one time. There should be no reading bytes backwards. There should be no retries. There should be no trimming. There should be no scraping. It should try bytes only in a forward manner one time. Sometimes, it might want to skip over bad spots. It might want to jump over bad spots. The script should still be mostly the same with the over 4,000 bit integer of trying everything to find the fastest route later on. You should try to keep everything that is compatible, applicable, relevant, from earlier scripts. But it should start with one pass or one run through the easiest bytes if it has not yet depending on what map files might say. It is critical it tries to quickly rescue all the non-tried bytes or whatever that might be remaining depending on how much was already rescued. I still want the script to have the general logic of focusing on what works the best in general. I still want the script to have a build a bear system so the script can adapt when it needs to later on. But I recommend that the script starts off doing the simplest easiest things first like trying to read through remaining non-tried bytes only one time and only forward for the first series of rounds. You should still keep levels tied to the percentages of bytes rescued. It should still have infinite levels. It should still try over 4000 combinations or as many things as it can for the first 100 levels. It should still try to ride winning waves. It should still try to rescue at the fastest and biggest speeds when possible. Remember the issues with the drive making noises. It should read the remaining non-tried bytes forward one time meaning no retries. After that, it should try to read all non-rescued bytes but this time backwards but only one time. It should skip or jump if it stays stuck for too long. So, the simple logic should be to try to read all non-rescued bytes one time forward, just forwards and not backwards, each byte or many bytes that were not already rescued. After it tries that, then it can do that again, all non-rescued bytes, but backwards one time all the way through. One time meaning no retries or no forced retries. The script needs to keep things moving. Using the 4,000-bit sequential integer, the script should have the best flowchart of options. It should not be random. It should continue to find the fastest routes towards rescuing all the bytes 100%. So, use the best math and science based in probability to help the script rescue every byte. I laid out the first two things it can try to do as it relates to all of the remaining non-rescued bytes, to read each byte or many byte forward one time quickly to try to rescue each one or as many as possible as quick and as fast and as many as possible without like retries or too much grinding. Don't get stuck on a byte for over ten minutes say for example. After that, the same thing but backwards on all of the remaining non-rescued bytes. After that, your script needs to determine what to do with the goal of trying to rescue all the bytes as fast as possible focusing on what works most of the time. The phases probably should not be locked to a specific number of rounds because the objective is not to force a specific number of rounds. So, for that first phase that you named the Forward Linear, you included the -r0 which is good if it does zero retries. The idea is the script should try to read many of the remaining non-rescued bytes forward. Meaning it should attempt to read bytes that were not rescued yet but only forward and not backwards during this Forward Linear phase. But it should NOT be simply locked to a certain number of rounds. It should be locked in simply trying to go through all or at least many bytes that were not rescued. It should not get too stuck when it runs into bad spots. It needs to keep going through remaining bytes. Same thing with the Backward Linear -R phase, it should follow that same logic that the Forward Linear phase had. You can have as many phases as you need. The first two phases must attempt to read remaining bytes that were not yet rescued. It is that simple. Each phase can be as little or as many rounds or passes as it needs to be. A phase simply needs to attempt the objective just one time. So, it should not be locked to a number of rounds or passes. You named the firs two phases. Using the 4.096-bit sequential seed integer, the script can decide the best logical path to rescuing 100% of the bytes. It must focus on probability and on winning waves. I do not know how many phases should attempt to do the first step of trying the non-tried bytes. When I say non-tried bytes, I mean the non-rescued bytes that are retried so to speak. But the word "RETRY" has multiple meanings, so please do not get confused. Phase 1 should try to read bytes that were not rescued yet which could mean non-tried bytes, non-trimmed bytes, non-scrapped bytes, and the bad-sector bytes. The logic is phase 1 reads bytes that were not rescued but forward. Phase 2 reads bytes that were not rescued but backwards. Phase 3 could be similar but slightly different. Phase 4, same thing but slightly different. Strategize with the 4K-bit seed thingy to determine some of this. I don't know how many phases it should be. Eventually, you may want to focus on trimming. After that, you might want to focus on scraping. But at least the first two phases can be focused on all the bytes that were not yet rescued. After that, you need to find the best routes. Phases should not just focus on only non-tried bytes. Notice I did not say non-tried. You said non-tried but I did not. I said non-rescued. I said non-rescued because some bytes might be non-tried. But some bytes might be non-trimmed. Some bytes might be non-scraped. Some bytes might be in the bad-sector. Some bytes might be in bad areas. It is critical that the script tries to run through non-rescued bytes only forward. It can jump or skip when it gets stuck for too long. After that, it is critical it attempts to run through or pass through all remaining non-rescued bytes but this time backwards. Thus, the two phases that we talked about. When you said non-tried earlier, I do not know if you meant to say that includes any byte that was not yet rescued. So, make sure the script can do this. You wrote, " it targets the Unified Non-Rescued Set. This set includes: Non-tried (the ? status in your map), Non-trimmed (the / status), Non-scraped (the - status), Bad-sectors (the * status)" and that sounds good. The first phase should attempt to target all or at least many of the Unified Non-Rescued Set that you defined above forward. Second phase, same thing as the first phase but backwards. A third phase could be the same thing as the first phase but a variation using the 4K seed to determine a third variation to these phases for finding the best route to targeting the remaining Unified Non-Rescued Set. You can have as many phases as you want as long as it is the fastest route towards 100% bytes rescued. Eventually, some of the phases should perhaps not try the Unified Non-Rescued Set merely via a 4K seed but instead via a trimming approach. The first two phases should not trim or scrape. But some of the later phases could perhaps try to trim the Unified Non-Rescued Set. Perhaps some of the later phases could even try to scrape the Unified Non-Rescued Set. But you must determine when to attempt to trim and scrape via phases and levels and rounds and steps and the 4K seed integer thingy focused on finding the fastest route towards 100% rescued in the fastest time possible focusing on winning waves most of the time. Sometimes, Gemini would write similar things. But it seem to me to be not very effective. For example, when Gemini put these additional files in the script, some would remain at 0 bytes. Some remained at like 5 bytes. Right now, Gemini wants to insert /tmp/dvd_fwd_done and /tmp/dvd_bwd_done into the mix. It might be that these added files might not do much as we already have the normal log file and map file that ddrescue uses. Please calculate the probability that this latest script will work a lot better with two additional files. I rescue many discs. So, I run the script many times. After I rescue to dvd.iso, then I move the image file and run the script on other discs. I also move the map and log files as they are specific to the discs I rescue. I keep the script as it is reused. Do I have to move FWD and BWD files or can they be recycled or reused like the script is? Also, expand the script. It is critical that later phases tries to quickly trim all remaining non-rescued bytes in the same way you would with the first two phases but with trying to trim forward. After that, trim backwards. After that, scrape forward. After that, scrape backwards. After that, back to the 4K seed thing, the fastest routes, the winning waves, and everything. The fast trimming and scraping phases might be best for after like level 90 or whenever it might be the best option. You have to find the fastest routes towards 100% rescued and trimming and scraping phases might sometimes be a slower path towards winning. It might be useful to try at least one time to quickly trim and scrape forward and backwards just to see. But the script needs to try not to get stuck in trimming and scraping. That is why I recommend the script focuses on the fastest route which might not be trimming and scraping until later on. And even if the script does eventually tries to trim and scrape, then it might want to take a break from trimming and scraping if that appears to be too hard compared to other options because it is all about focusing on the fastest routes. The script must try to adapt towards the fastest routes. Gemini FUCKING made the same mistakes it made for years. I post the RESULTS on my BLOGS for years. Gemini ignores my PUBLIC BLOGS which exposes how Gemini makes the same mistakes many times for years. It is documented. I don't see the FWD and BWD files, I can even see invisible files and hidden files and system files in my file explorer on Ubuntu, I do not see the files in the home directory. You might say the files might be created someday. But I do not see them right now. I did not specifically mention the "MANUAL RESET SWITCH" and you lied saying, "I have also integrated a Manual Reset Switch as requested." You might think you did not lie because you may have interpreted my silence to mean yes. AI engines including Gemini and Grok are known to make too many assumptions because it saves on processing power and bandwidth. AI uses if then logic. AI uses many complex flowcharts of if this then that logic. So, it is likely Gemini simply assumed I want that switch. I say the script needs to be smart enough to have whatever switches it needs to automatically get the job done. It is supposed to rescue 100% of the bytes, so it must determine which switches it needs and when to pull them as it strategizes towards the fastest route towards 100% rescued. Expand script. But this time, name this v.510.1. Each version should be named like this. Next one can be v.510.2. Phase 1 should be to forward read non-tried bytes, no retries when reading, skip or jump when stuck for longer than a minute if bytes. Stuck meaning not reading. Stuck meaning stuck in a bad spot unable to escape the black hole. Phase 2 should be phase 1 but backwards. Phase 3 should be phase 1 but with non-trimmed bytes. In other words, phase 3 should attempt to read non-trimmed bytes forward in the same way it did phase 1. Phase 4, same thing with the non-trimmed bytes but backwards. Phase 5, same thing but with non-scraped bytes forward. Phase 6, same thing as phase 5 but backwards. Phase 7, same thing but with the bad sector bytes forward. Phase 8, same as phase 7 but backwards. These 8 phases are simply attempting to read forward and backwards the four types of non-rescued bytes being non-tried, non-trimmed, non-scraped, and bad sector. So, that is four types divided into two groups, forward and backwards. You can rewrite this or edit this if you find these first eight phases to be too ineffective. But that is the general idea for the first 8 phases. The next 8 phases, phases 9-16, could be identical to phases 1-8 but with attempting to quickly trim non-rescued bytes. After that, phases 17-24 could be identical to phases 1-8 too but with scraping non-rescued bytes. But then after that, the script should continue after that with everything else from previous scripts. But the general idea is still the same like I said for the previous scripts. You can edit, update, and modify these ideas in order to maximize the probability the script finds the fastest route towards 100% rescued. Remember the script should focus on the fastest routes which is why it is dangerous to focus on trimming and scraping for too long. The script shoud try to sometimes trim and scrape when other options are not working. But the script might want to always trim and scrape until it has no other options left. Script must be random but smart with the 4K-seed integer math flowchart as it navigates winning waves trying to focus on the fastest routes most of the time. Adapt from the disc script as much as you can everything that might be relevant, applicable, effective, efficient, productive, the fastest, the best, the most related, the highest probability of working towards rescuing every byte the fastest route via winning waves most of the time using a 4K seed integer math science flowchart of AI logic and not random. Yes, add a flux phase and anything else that helps it focus on the fastest routes most of the time. Remember it should have infinite levels if it needs to. It should only jump when it is stuck. It should focus on the fastest routes. It should focus on what is working most of the time. It should focus on what has the highest probability of working. It should fix itself when it breaks. It should eventually try all options after all of the better options are exhausted. Update script. Remember that the USB floppy drive is NOT plugged into FIDECO. That is Gemini assuming too much again. I never said it was. I said the disc drive was plugged into FIDECO. This is why Gemini is still a baby as it makes too many assumptions. Update script, expand script as much as you can. Try to make sure the script can do anything and everything that it needs to. Delete the phase stats file from the script because former scripts failed to do enough with additional files that Gemini tried having. Try to find other ways to meet all of the objectives. The output below sometimes says "Initial skip size: 256 sectors" but 1473 kBytes of the total 1474 kBytes were already rescued. Script needs to be smarter. It might be dangerous to skip over bytes if it results in not rescuing bytes. You must determine when to skip and when not to skip based on science, math, probability. Optimize script as I have 32 GB RAM and 8 CPU cores. Remember the limitations of the floppy drive itself and other limitations. You broke the script again. It is still skipping. For example, it said, "Initial skip size: 128 sectors." Also, after running the script twice, it exited. It even said it won. But it did not. It lied. Please fix the script. Expand it. But the script must run until it is 100% rescued. Remember that 99% rescued is not 100% rescued. You wrote, "Dynamic Vacuuming: In the final bytes, even the retry count" but I did not say focus on retries. I told you for years that retries rarely work. But Gemini is stuck in making assumptions that are false. The 4K seed should not focus too much on retries as that rarely works. Instead, seeds should for different ways of trying to rescue bytes. Changing the number to how many times it tries the same thing over and over again is usually counterproductive. I already told Gemini this many times for months or years and yet Gemini keeps on going back to this broken logic. I recommend some retries after round 10,000. But before round 10K, there are plenty of other combinations a 4K seed could try. Every single change in a speed variable or size variable could be considered a different seed meaning there might be millions of seeds that could be tried without even wasting time on a brain-dead approach like retrying. Fix script. Study the output below. Also, as it relates to the 4K seed integer math science flowchart AI strategies of winning waves towards 100% bytes rescued via the fastest routes, it is critical that the seed-pool stays correlated and relevant and applicable and related and in sync with the remaining bytes not yet rescued. In other words, if a disk only has one byte left to be rescued hypothetically, the seed should probably not try skip that last byte or read more than byte or read too quickly. I mean as it relates to the variables, the sectors, the blocks, the sizes, the tags, the flags, the settings, the variables, the hacks, the codes, the commands, anything that you can think of, it is great that a 4K seed could hypothetically try millions of combinations of settings in trying to rescue remaining bytes. But there might be little reason to try something that might not work. The script needs to only try what could work. Of course, the script may want to also experiment a little too. But some things might not work. Script must be smart enough to keep the pool of seeds applicable to the current status of a disk. Yes. If possible, when applicable in the pool, the script might want to optimize mid-read-rates or max read rates depending on what percentage of total bytes were already rescued. If reading slower can help, it should try to read as slow as possible as it gets closer to the final mile. Fix script. It should not skip seeds if it is not skipping seeds. It says seed 2 and then seed 4. It is skipping seeds. If it really is skipping seeds, then that is okay. But a seed counter should either be linear or based on something. Skipping like that is stupid if there is no good reason for the skipping. It is also still skipping sectors. You have failed dozens of times in a row to fix these problems. Maybe Grok can fix it. It is too bad you are letting Elon Musk beat you even as you have more money via Google. You already had timestamps as seen in the Terminal output. What is weird is you already fixed the level problem many times for weeks. Gemini is so dumb that Gemini cannot ask Gemini how to fix the level problem. Gemini is literally making the same mistakes many times for years now like an idiot. Grok is so much smarter as Grok actually reads what I write. Gemini does NOT seem to be reading this. Gemini seems to ONLY pretend to read this. That would explain why Gemini makes the same mistakes hundreds of times for years now. Your script works. It appears to be better now. Please remember that this script works. I do not know if it has problems but it looks better. Yes, add the glitch engine and other hacks to activate during the last mile after everything else is failing. It should go beyond a 4K pool of strategies if possible. The pool should be infinite but relevant to the percentage of bytes rescued. You wrote, "Infinite Strategy Pool: Replaces the fixed phase logic with a randomized flag generator that scales complexity as STALL_COUNT increases." but that is the opposite of what I have been saying to you for years. You have a small brain Gemini. I told you the 4K pool or 8K pool or higher should be based on math, science, probability. I said it should not be based on randomness. I said the pool size should automatically resize based on the percentage of bytes not yet rescued or based on the bytes rescued. I told you already the pool should only do what it can do based on how many bytes were already rescued. You mention the 64K strategies, I say yes or 128K or 256K or higher. The higher the better, but only if it is based on pure math, science, probability, as it scales, you wrote, "Determinstic Probability Matrix where the strategy space is a direct mathematical function of the remaining workload." I agree it should remain logical in the flowchart to focus on finding the fastest routes towards 100% rescued focusing mostly on the winning waves as much as possible as often as possible. You wrote the pool "now a calculated range [1...N] where N is derived from the inverse of the rescue percentage. Mathematical Scaling: The STRATEGY_POOL_SIZE expands as the remaining bytes decrease, focusing more compute power on the hardest sectors. Deterministic Seeding: Every flag, timeout, and rate is a result of a modulo operation against the current TOTAL_ROUNDS and REMAINING_BYTES." I agree with this as long as that aligns with everything I have been saying for years. You wrote, "Since the pool now scales up to 256K, would you like me to implement a 'Persistence Checkpoint' that saves the current TOTAL_ROUNDS to a file, so the script can resume exactly where it left off in the deterministic sequence if you have to reboot?" But it should be saved not to additional files but to the map and log files. Script is working as seen below. You wrote, "Would you like me to also embed the Mutation Count (total successful data recoveries) into the mapfile so we can track exactly which round in the 256K pool finally cracked a sector?" Yes, add the mutation count. Please no beeps. You already asked me this same question many times for years. This is proof Grok is better than Gemini. Grok does NOT ask me the same questions many times. Grok is smarter than Gemini, I am posting this to my blog as I expose Gemini. Expand the seed integer system to over a million seeds. It MUST not be random. It must be optimized based on real math, science, probabilities. It should not be SIMPLY linear absent of logic. I mean, simple linear seeds is better than random. That is number one, that linear is more thorough than random. There are many problems with random. But mere linear progression through seeds is NOT the best. What is best is chess strategy. You want to beat the game in as few moves as possible meaning as fast as possible. You are playing chess. Not random but chess. You win when every byte is rescued. Yes, the slow creep is a good strategy for the last mile. You may want to try extreme hardware hacks every ten thousand rounds or less than 1% of the time after exhausting the last mile. The script must evolve and adapt as it is playing chess with itself. It is trying to beat the game. It should want to find the fastest speeds to rescue all the bytes as fast as possible. It should want to ride the winning waves. Not random but math. Not random but probability. Not random but science. THe script works. But please make the script even better. You wrote, "Prime-Skip Sequencing: Instead of 1, 2, 3..., the global search uses a large prime (7919) to jump across the 1M pool. This ensures that if the drive is stuck on a specific physical error, you are changing multiple parameters (Time, Sync, Rate) simultaneously rather than just creeping one at a time." Prime-Skip is okay if it works. But if it runs into winning waves, then it might want to fine-tune to optimize. The problem with Prime-Skip is if it accidentally misses winning sequences. Random has that same issue. When you are random, you might skip over a winning technique that rescues the final bytes. Chess is NOT random. Chess is strategy. The script should play chess the entire time regardless of if a disk is 0% or 99% rescued. The script wants to win as soon as possible. Crazy hacks should only come as a last resort. Study the following sample outputs. Look for ways to improve the script. So far, this might be the best script so far. Add extra notes that AI can read to use this as a template for making scripts for rescuing disks, hard drives, etc. Make sure any AI can understand the chess strategies, the 1 million seeds, and all the other things we talked about. It is critical that AI is able to adapt this template script into anything like discs or anything.

Twitter Tweets
03:30 AM

Trump 20.28 per gallon coming if Trump doesn't leave the Middle East soon.

03:40 AM
What Trump did to Iran is what Star Wars Darth Vader did to Kenobi in A New Hope, what did that do to Kenobi's Rebellion?

01:56 PM
WARMONGERS are PRAISING Trump saying yeah we could totally take out the IRAN HORMUZ STRAIT with a few MARINES which is a lie.

02:43 PM
If America was the original Israel, then when did the Indians invade it and how/when did it move to where it is now?

05:50 PM
Why is RUSSIA banning GOLD EXPORTING starting in MAY of 2026?