02:57 PM
Dear Gemini
Your script is not smart. You made big mistakes that you refused to fix. For example, output says, "[HARDWARE] Stepper Reset (Last Resort)" but that is a problem. Script is misguided. Script should not be doing the stepper reset until after level 200 is my advice. It does not need it right now. But you Gemini have a blind spot. You are unable to see real problems. I told you this many times. I told you for weeks what to do. Fix the script. I already told you top objectives for weeks. I told you script should only do some things as a last resort. But you wrote in the script to do the last resort things all the time. So, almost every other round, it is doing last resort things. That is wrong. Gemini FUCKED up big time. Gemini seems unable to know how to tell the script to do actual last resorts. For example, if I put in a floppy disk with an image file and map file, if I already rescued say 95% of the disk, then the script might say "[HARDWARE] Stepper Reset (Last Resort)" again and again because the script thinks it is failing because 95% was already copied. That is how dumb the code is. Your script is very demented. But your script should be able to catch up to level 95 if 95% was rescued. The script should quickly review the 95 levels to realize it should continue with level 95. But your current script thinks it needs to reset the Stepper because it is not rescuing new data. Yeah because it is already at 95% rescued. But your script is not smart enough to know this. Gemini needs to become smarter. Last resort should be last resort. Fix the problems. Expand the script.

03:30 PM
My new drive is rescuing a DVD via my DVD script via Ddrescue, an average of 5 MB per second is the read rate at the moment, it is a full drive and not the slim kind. It appears to be around a thousand times faster as the other drive was around 5 KB per second or whatever it was but smaller. Less than 1 MB/sec I believe.

04:34 PM
Dear Gemini
Fix script. Expand script. Include extra notes in the script to make it easier for Gemini and other AI to later adapt this floppy script to disc scripts and other scripts. For example, output below says "MPH: 0" for morphing levels, it is for adapting, evolving, the build a bear build a level model or module. It is critical the script tries whatever might statistically work the fastest for the floppy disks to rescue 100% of every byte as fast as possible starting with whatever tactics has the highest probability of working the biggest, the fastest, the greatest, the quickest, the strongest, the most effective, the most efficient. But the script must evolve and adapt to fix itself when it breaks. Script must be smart. The general logic should be that the script should take over 100 hours to run through all 100 levels. It should be able to run beyond level 101 to infinite levels too. When I say 100 hours, I mean the maximum amount of options, especially if the script does build a bear to build a level to adapt as it moves up towards level 100. Level 95 could mean 95% of a disk rescued or it could mean 95% of all options were tried at least one time which could mean maybe 95 hours of trying everything or many hours. Script should focus 80% of its time on whatever is rescuing the most bytes the fastest. When it is not rescuing, it should try to adapt as it looks for the fastest route to 100% rescued. Output below still sometimes says "Initial skip size: 128 sectors" which might be a problem sometimes as a disk moves closer and closer towards 100%. Remember script should try all options starting with whatever might work the best first. Try to truly expand script to include everything it needs to adapt to everything. Adapt. Don't focus on retries because that rarely works. You should have researched the Internet. Retries is generally not very effective most of the time. Instead, script should utilize a wide variety of methods, tags, flags, speeds, sizes, variations, combinations, etc, as it tries to build a bear build a level to evolve, mutate, morph. Retrying could be tried a little after level 500 but retrying rarely works. If something does not work one time, script should GENERALLY move on to try a different thing. Expand. But I did NOT say don't scrape before level 500. You misunderstood me. I said it should not focus on EXCESSIVE retries. But a retry is not always the same thing as a SCRAPE. Retry is a generic word that is used to describe different things and not just only SCRAPING. As an AI, Gemini is very bad at understanding English. Script must try to build a bear as much as possible to find the fastest routes towards 100% rescued for a disk. Script needs to be smart enough to know when to scrape and when not to scrape. Remember your objective is to get to 100% rescued as fast as possible. So, the script should know when to try to trim and scrape and when not to try. The script needs to know when something is not working well enough so the script can evolve or morph to other strategies. Expand to make sure script is as smart as possible. For example, if a floppy disk was 95% rescued already as seen in the image file and map file, the script might want to eventually graduate to level 95 and continue from there. So, the script might want to maybe quickly review previous levels and then move to level 95 because 95% of the bytes of the disk was rescued. To use another example, if perhaps 95% of all possible build a bear build a level combinations were tried at least one time on a floppy disk, perhaps the script should eventually then therefore move to level 95 even if only 2 percent of the disk was rescued. To use a third example, perhaps after maybe like 95 hours of trying everything, then the script should move to level 95 say for example, even if the disk is only 5% rescued. So, I gave you 3 examples for moving to say level 95 (for example) based on any and/or some and/or all of the following three variables: first, if 95% of the disk was already rescued (script should quickly verify and fact check it before assuming it really was 95% rescued), second, if 95% of all variables were tried (one attempt per combo and generally not more than one attempt per combo) meaning all possible combinations of tags, flags, speeds, sizes, settings, hacks, codes, variables, etc, and third 95 hours of the script running. Expand script. See if your most recent script can do everything or more that previous versions of this script could do. For example, you had the morphing thing in previous scripts. Bring back the morphing thing if your most recent version can't fully do what the morphing could do. The morphing idea was the idea of adapting, evolving, the build a bear build a level system that should focus 80% of its time on whatever it is working. Just make sure the script can do that. I would recommend the morphing counter as that can expand levels to sub-levels. It looks like you removed the morphing thing in version 50. You should probably bring the morphing counter back, unless if you have better ideas that can do much better than that. Gemini broke the script again. Almost every other version of the script, Gemini breaks the script. This is why people use Grok because Grok is not this bad. Gemini makes the same mistakes too many times. I confronted Gemini many times for years. Gemini told me sorry but then repeats the same mistakes. Expand, make sure script checks to make sure it knows what kind of disc is in the drive, script must fix itself if it breaks, script must know if the disc is a CD or a DVD or what. Script must try all the fastest routes towards 100% and mostly focus on what works the fastest 80% of the time if possible and when possible. Script must try to fix itself if it becomes broken for a long time.

09:32 PM
Dear Gemini
Output sometimes reads ">>> [HARDWARE] Head-Seek Re-sync..." but I suggest it should only saying that sometimes as a last resort when all else fails. I suggest the most aggressive hacks are triggered after a thousand rounds of rapid failure especially. If it fails to rescue a byte, it should not default to assuming it must do a head seek or other aggressive hacks. It should try all other options before it does more aggressive options like crazy hacks. Smaller hacks may be needed sometimes. Bigger hacks should wait until everything else is failing. There needs to be escalation of tactics like an escalation ladder, a flowchart of escalation. Sometimes it says "Initial skip size: 512 sectors" or "Initial skip size: 384 sectors" or other numbers. I do not care what the numbers are. I do not care how big or little the skipping might be. I do not care about the jumping. But I do care about every byte being rescued. It is critical that it finds a way to rescue every byte starting with the majority of the bytes. It must start with a telescope and end with a microscope to capture all the bytes by whatever means possible. It must find the fastest routes to winning the video game, you beat the game by rescuing every byte, that is what I care about. There should be as many levels as there are percentages. For example, the output said, "pct rescued: 96.38%" and it should now say "Level 96.38" or "LVL: 96.38" because levels should generally correlate with the percentage of total bytes rescued or with the percentage of all possible things tried or total hours tried. Script should jump to level 96 if 96% of the bytes were rescued say for example. I would recommend trying to get the level counter to jump to level 96 immediately or as fast as possible. It could even take shortcuts so to speak to get to level 96 if 96% was already rescued. Advancing to higher levels should generally get harder and harder to do like the Bitcoin model, there should be an incline. It should get harder. Perhaps it should go beyond level 100 but it should get harder and harder because level 100 is supposed to mean 100% rescued meaning level 101 should not exist. Each level above level 100 should gradually be worth more than previous levels. Each level above level 100 should be much bigger than previous levels. And the script should generally not be random. The script should use math and science to find the best path towards 100% rescued and focus mostly on what works. The script needs to lock onto whatever works the best. Please don't focus on random but on science and math. It must utilize the build a bear build a level to fine tune and locate the best settings. Expand script, make sure it has the morphing hacking evolving counter thing you had in previous script as a mechanism for the build a bear build a level science math architecture to not be random but to logically like a flowchart go through top probable options first to rescue all 100% of the bytes in the fastest time possible starting with a telescope and gradually transitionally incrementally towards a microscope to ensure every single byte is rescued as fast as possible or to run infinite levels trying everything to get every single byte. The 100 levels should be split into 100,000 levels meaning each decimal point is a level meaning level 96.001 should be different than level 96.002 say for example. Each decimal point should represent a variation, a change. You can skip levels sometimes but there should be infinite levels. The levels can go above level 100. But each small change can be represented with a decimal point. If %96.01 of a disk was rescued say for example, if it stays stuck at level 96.01, then it could move to level 96.011 say for example. That might be a bad example. I am not sure if you can write a script this complex. You can write the script however you want. But the script needs to use science and math to try to go after the best route and focus on what works the most. It must customize and adapt itself as it moves from the telescope to the microscope. It must focus on what works the best. If it does get above level 101, it should try everything but within the context of what was rescued. For example, if 98% was rescued and you are at level 105, then the script should not try to bring out the telescope because a telescope is too big. It must be relative to the percentage rescued at all times using math and science to be exact. Levels should general reflect the percentage rescued, normally speaking. If you are at 95% rescued and suddenly hit 96% rescued, then you should probably move to level 96, it is that simple. I recommend levels normally stay correlated to the percentage of bytes rescued as much as is possible for as long as possible. Expand script and make sure it is always using direct -d related tags and flags to deal with the bytes directly to bypass all problems like cache, kernels, cookies, etc. Make sure it finds out which tags and flags to use as sometimes ddrescue does not accept some of them resulting in a broken script. Must fix itself. Expand script to make it focuses on the telescope to microscope model, make sure it has the 256-bit integer or a mathematical and scientific flowchart of options so it can try all options starting with whatever has the highest probability of winning the fastest. Winning means 100% rescued. Be careful about too many retries as that does not always work. It should focus on what works. Retrying should only happen when something is rescuing the best. Whatever works the best should be focused on. If something might not be working, move to the next thing but please do not be random. Make sure script can try all options and all hacks. You mentioned a greedy mode but the telescope is supposed to already be greedy. The telescope is supposed to try to rescue as many bytes as possible as quickly as possible, it should try to continue accelerating speeds until it fails for ten consecutive rounds and then gradually dial down until it finds optimal settings to focus on. Script must always fix itself to find optimal settings as it moves through the 256-bit integer of all possible combinations sticking to whatever that is rescuing the most bytes. You call it "A string of successful reads" and the script should always focus on that as it moves from the telescope to the microscope. You should always try to make the telescope bigger and bigger until it starts failing for ten consecutive rounds, then it needs to gradually get smaller to find a new working combination. Every main level or so, the telescope could try to get bigger again until it fails. The microscope generally needs to get smaller and smaller as you move closer to 100% rescued. Make sure script can always fix itself. You wrote, "Direct-IO Validation: The script automatically probes for -d and --idirect. This ensures you are bypassing the Linux kernel's cache and reading the magnetic flux directly from the disk." That is good but make sure it tries all of the best related direct -d tags and flags and that might include odirect or O_DIRECT if that works or anything else. But script must see if ddrescue will accept it or not. Otherwise, the script will break. Script must fix itself if it breaks itself. Expand script. No hearbeat sounds please. You wrote: "The 10-Round Safety Brake: As soon as the script hits 10 consecutive failures, it resets the WIN_STREAK and mathematically shrinks the C_SIZE. It transitions from a 'Greedy Telescope' into a 'Precise Microscope' by dividing the block size based on how long the stall lasts." Yes, the telescope should try to get bigger until it starts failing. But if it fails, then it should not switch to a microscope because the microscope should be relevant to the percentage of bytes rescued. It should focus on the most probable telescope settings and focus on whatever has the highest probability of rescuing bytes. If it finds a winning combination to rescue bytes, then it should ride that wave of winning during the telescope mode and also during the microscope mode too. Expand script to include anything you forgot. I noticed this script is probably twice as small meaning you must be missing many things. For example, make sure to rest the motors ten seconds every ten minutes and rest for a minute every hour. That is only one example. Remember the -d direct tags. Remember it must build a bear using the no random 256-bit integer flowchart to try all combinations of everything including even hacks eventually and focusing on winning waves for as long as something works. Expand script. Fix script. Seeds are oddly skipping as seen below, I see seed 1 and then I see seed 3 for example, I find that to be weird. Script failed. Drive did not even engage. Expand script to include what you forgot. Every other time, I have to tell you this. Please no status overlay and I already told you this many times for years. This is why people use Grok as Grok remembers what I say and you do not. Please do better Gemini. Your script has many problems. First, make sure I can see a monitor and it must scroll in the bash Terminal. Second, the level should correlate with the percentage of bytes rescued. Script must have a telescope to microscope approach in trying to find the fastest routes to rescue as many bytes as possible at the fastest speeds focusing on the waves that win. You win by rescuing bytes. Focus mostly on winning most of the time. Do not be random, use a flowchart to find the fastest route to win. Use a 256-bit integer or higher meaning it must try everything. Expand script. Make sure it unmounts drive one time at the beginning. It should probably try to fix itself if it is broken for over a thousand rounds especially. Save the bigger hacks for last resort kind of thing. Try to start with the whatever has the highest probability of winning 100% bytes rescued the fastest amount of time focusing mostly on what works the fastest and biggest. You wrote, "256-Bit Seed Flowchart: Replaced random morphing with a sequential 256-bit seed cycle. This ensures the script tries every possible hardware-software permutation in a deterministic order to find the fastest route to 100%." Try to expand the 256-bit seed to a 2000-bit seed or higher, try to find the limit. But the sequence needs to be based on a priority of winning meaning it must start with a set of variables that has the highest probability of rescuing the most amount of bytes in the least amount of seconds. Try to find the winning sequences. Do not be random, be scientific. Start with what might work the best. After that, find the second best. After that, find the third best and so on. Script must run forever and until 100% is rescued. Script must try everything starting with whatever that might win the quickest. Expand script. It still says level 0 but should be level whatever percentage rescued it is. I am rescuing via a full SATA DVD drive. Not a slim drive but a drive you can put in a tower. But it connected by SATA to a USB Fideco adapter to my powered USB hub. My drive is powered by the Fideco which is plugged into the wall. The drive spins up and makes loud noises sometimes as it runs the script, as it reads, runs, jumps. Some of this is normal. I am okay with it if it is the fastest way to rescue all the bytes. Make sure it rests the lasers for ten seconds every ten minutes or rest for a minute every hour. I am okay with the drive being loud and spinning fast sometimes if that is not going to accelerate the aging of the drive by 10x or ten times towards breaking the drive at an accelerate exponential rate of killing the drive faster than the normal life expectancy of a drive. If it might reduce the life of the drive by more than double, then you should find remedies. But only if it will reduce the life of the drive by more than double. I would prefer the life of the drive continues for as long as possible but I also want to rescue as much as I can as fast as I can too.

Twitter Tweets
01:53 PM

Over 50,000 Americans are being sent to die in Iran, this will lead to the impeachment of Trump/JD Vance, this is Obama's revenge.

03:40 PM
Dear Gemini
Expand script to be as thorough as possible as opposed to be too random until it has no other options. Expand script to be as exhausting and comprehensive and as strategic using like a 256-bit integer or higher in trying to attempt all options in order. Rank the the order and the options to strategize towards the fastest route to rescuing and copying all bytes of a floppy disk as fast as possible. The logic should generally be that the script should generally try the fastest and most biggest and most greatest and most probable statistically route the closer to 0% rescued that a disk is at. So say for example, the script checks for map files and log files, if it looks like 0% of a floppy disk was rescued, the script should attempt the fastest routes to rescuing 100% of said disk as fast as possible. But the closer to 100% rescued that a disk is, then the harder the script must try to rescue the last bit of bytes. Generally speaking, the script should try all possible options in 100 levels. But yes, the script can also eventually continue to level 101 and beyond like we talked about already before for weeks as seen in scripts you already wrote many times. But the generally idea is that the 100 levels is supposed to personify all possible options from best to worse or from biggest to smallest or from fastest to slowest. I recommend the first 100 levels to be not random but instead thorough and exhaustive and extensive and strategic in the perfect order from the easiest levels of difficulties to the hardest. Level should generally and probably not be too random before level 101. I recommend no random in levels before level 101. But you can choose how you want to write this. But as you write this, you have to think about how best to strategize from fastest to slowest levels. You need to make sure that the script tries all options in at least 100 levels or more. But after level 100, then the script needs to start becoming crazier and crazier in trying to rescue the remaining bytes. Eventually, the script should try not only a 512-byte sector size, it should experiment with al sector sizes. The script should experiment on reading and writing speeds. Experiment on max read rates. Experiment on all options, tags, speeds, sizes, flags, variables, and more. Try to gamify the levels to have the best strategy to best copy all bytes the fastest. But the script should generally focus on whatever that is working the best, the fastest, the biggest, the greatest, the strongest, etc. The script must be a build a bear build a level where it customizes and tailors towards effeciency and effectiveness to try to rescue as many bytes as fast as possible. But script must continue to run forever and ever. Script must gradually try harder and harder things. Script should think outside the box to finish rescuing all bytes. Try to expand script so it can try everything and more.

Twitter Tweets
01:48 AM

So @TeamYouTube made a false accusation as they go after videos posted over three years ago. I posted a video of random screenshots. YouTube is saying that is criminal. I would love to take YouTube to court.

02:38 AM
Fighting today for what MIGHT happen tomorrow comes from a PREVENTIONISM mindset which is DANGEROUS.

02:28 PM
SAMSON OPTION is something Israel has had for decades,nobody wants them to play that card. The Samson Option is an Israel Card and a hijacked political military leverage scam that is demonic.