The Linux Thread - The Autist's OS of Choice

  • Want to keep track of this thread?
    Accounts can bookmark posts, watch threads for updates, and jump back to where you stopped reading.
    Create account
ProudSkibidiTolietAryan said:
STEAM HARDWARE SURVEY IS IN AND OH MY GOSH
Click to expand...
Im going to say Linux will reach atleast 8%, if not more by the end of the year. Perhaps double digits?

ProudSkibidiTolietAryan said:
i really love gnome. Honestly. That is my hotake. I like it better than windows and Cinnamon
Click to expand...
Gnome would be the go to DE if they stopped doing the "my way or the highway" shit. People want system tray icons that dont break every major update. People want to theme their applications. Developers want things you don't, stop NACKing them and ruining the progress of people trying to move forward.

But trannies need to grandstand and ruin everything.
 
HootersMcBoobies said:
I started watching this video, saw that Abiword was still in Gentoo portage, and was able to compile it and its dependencies before the video ended.
Click to expand...
Goddamn, that took me back. Abiword was one of the word processors I used in the early 00s after I started my move away from Microsoft and proprietary software.
 
I can barely stand LO. The UI is hideous and for folks that are more accustomed with Excel some things doesn't make sense at all. It is more streamlined in MS office suite to be honest and LO approach is similar but not alike. I could bring thing or two about the workflow that not only differs from proprietary standard but the thought behind it is so convoluted that only a person that uses for really basic things could come up with such resolutions. At least the compatibility with Excel formulas is nearly excellent but there was a time that I had to reinforce myself with AOO because the latter had a better compatibility at the time to files I had on my PC.

The OnlyOffice suite is somewhat better with UI that is sleek and copies best standards from Excel, but again for person who is accustomed with shortcuts from MS can be quite irritated that some shortcuts are cut and are missing. I am not talking about some convoluted and deep diving key strokes to do some magic on screen but more mundane stuff like missing Ctrl + D to copy formula from cell above. For Excel, ",23" and "23%" is treated alike and although OO is based on LO, the former can't do basic math without "%" sign in said formula.

Same goes for work on text documents that surprised me with distinguished "column" from "section" in text layout option. For me, as a person that was trained on proprietary software, the split of text in two vertically aligned columns was called "column". It is a standard since newspapers used up to dozen of columns of aligned text next to each other but for some unknown reason to me, somebody in LO community thought otherwise and had split the said option to "section".

I think if Linux came with really professional office suite that, at least, copycat the solutions from MS many office computers could easily migrate to Linux.
 
Last edited:
TerribleUser09 said:
I can barely stand LO. The UI is hideous and for folks that are more accustomed with Excel some things doesn't make sense at all. It is more streamlined in MS office suite to be honest and LO approach is similar but not alike. I could bring thing or two about the workflow that not only differs from proprietary standard but the thought behind it is so convoluted that only a person that uses for really basic things could come up with such resolutions. At least the compatibility with Excel formulas is nearly excellent but there was a time that I had to reinforce myself with AOO because the latter had a better compatibility at the time to files I had on my PC.

The OnlyOffice suite is somewhat better with UI that is sleek and copies best standards from Excel, but again for person who is accustomed with shortcuts from MS can be quite irritating that some shortcuts are cut and are missing. I am not talking about some convoluted and deep diving key strokes to do some magic on screen but more mundane stuff like missing Ctrl + D to copy formula from cell above. For Excel, ",23" and "23%" is treated alike and although OO is based on LO, the former can't do basic math without "%" sign in said formula.

Same goes for work on text documents that surprised me with distinguished "column" from "section" in text layout option. For me, as a person that was trained on proprietary software, the split of text in two align columns was called "column". It is a standard since newspapers used up to dozen of columns of vertically aligned text next to each other but for some unknown reason to me, somebody in LO community thought otherwise and had split the said option to "section".

I think if Linux came with really professional office suite that, at least, copycats the solutions from MS many office computers could easily migrate to Linux.
Click to expand...
I've recently switched my mother over to Linux and her up with OnlyOffice. One really annoying bug she's encountered with OnlyOffice is it will print landscape documents as portrait. The OnlyOffice developers have been aware of the bug for sometime now, but don't seem to think it's a priority to fix. Work around is to set it to print as portrait, but would be better if it just worked as expected. Also, there doesn't seem to be a way to edit the default templates with the Flatpak version of OnlyOffice. I'm otherwise pretty impressed with OnlyOffice, but the two issues I mentioned seem like fairly basic things they should address and yet haven't.
 
Linux From Scratch is dropping sysvinit support
With some regret, LFS/BLFS will no longer be developing the System V versions of the books.

There are two reasons for this decision. The first reason is workload. No one working on LFS is paid. We rely completely on volunteers. In LFS there are 88 packages. In BLFS there are over 1000. The volume of changes from upstream is overwhelming the editors. In this release cycle that started on the 1st of September until now, there have been 70 commits to LFS and 1155 commits to BLFS (and counting). When making package updates, many packages need to be checked for both System V and systemd. When preparing for release, all packages need to be checked for each init system.

The second reason for dropping System V is that packages like GNOME and soon KDE's Plasma are building in requirements that require capabilities in systemd that are not in System V. This could potentially be worked around with another init system like OpenRC, but beyond the transition process it still does not address the ongoing workload problem.

In the future, the LFS/BLFS 12.4 System V books will continue to be available. For the most part newer versions of packages in those books will be able to be built with the instructions from there, but will not be tested by the LFS editors.

The next version of LFS/BLFS will be version 13.0 and is currently has a target release data of March 1st.

As a personal note, I do not like this decision. To me LFS is about learning how a system works. Understanding the boot process is a big part of that. systemd is about 1678 "C" files plus many data files. System V is "22" C files plus about 50 short bash scripts and data files. Yes, systemd provides a lot of capabilities, but we will be losing some things I consider important.

However, the decision needs to be made.

-- Bruce Dubbs
linuxfromscratch.org
 
ProudSkibidiTolietAryan said:
View attachment 8481600
NAND support has been improved greatly and I can comfirm some great news.

QEMU can successfully now emulate this TV so well that the EXTRACTED Linux kernel from the bootloader can get ALOT further now.

View attachment 8481606
Sure it fails to mount but im pretty sure its because the BOOTLOADER gives it custom command line options. As opposed to a WEEK ago

View attachment 8481611
(IGNORE IT SAYING [BOOTLOADER] this is the LINUX kernel talking not the bootloader via uart.)
Its able to properly SCAN the "NAND" and detect bad blocks compared to before failing and saying all blocks were bad because of INCORRECT my incorrect read implementation for NAND.
Again not a SINGLE thing in this kernel has been tampered with to make it work better. All RAW extracted and done.
And now HERE

View attachment 8481614

Oh the bootloader? That has gotten further now.

View attachment 8481617
Just for new readers this is the extracted LOW level bootloader of this TV extracted and running in QEMU, it fails yeah but see that? It detects the partitions and labels them and also gets the start and end addresses of the partitions(How nice of it). Detecting the NAND device and properly doing things. I can say that I FINALLY think that its PAST that "Searching for boot.TDF error"
Click to expand...
ProudSkibidiTolietAryan said:
Hey im back just want to say i found a USER guide for this family of processors meant to be given out to customers(companys) and this processor is acutally INSANE. It does things that puts MODERN x86 and ARM to SHAME all while being from 2008!!!.
Click to expand...

Ill cut to the chase
When I said "Oh the bootloader? That has gotten further now.'
I was wrong. VERY wrong. as it turns out that was NOT the case. I just made it crash EARLIER instead of further from before.
Fixing it just leads to the EXACT same error that ive been debugging and trying to get past for a month.
1769994329919.png

EVERY DAY FOR ALMOST id like to say almost my ENTIRE day its been trying this testing that. I had ONE glimpse of hope only to realize it was illplaced.

So I went back.. Took a DEEP step back...
And I went to reverse engineer(Which I BARELY have any expierence in) and name almost EVERY SINGLE FUNCTION in the bootloader.

Screenshot From 2026-02-01 16-35-05.png

And this includes labels as well(Labels are pretty much variable names, strings or pieces of data. These are not functions)
labels.png

And then adding COMMENTS to those functions of things with importance
1769982783919.png

And let me tell you. Some of these functions are FUCKING absurd. Like for example this one
1769982988472.png
This one is straightforward and simple being STRLEN. And its ok if you did not know that because well.. I don't expect anyone on earth to look at a few psudocode assembly code instructions and say "OH THATS THE C STANDARD LIBARY FUNCTION XYZ"

Ok now lets look at this one.
Code: 
void Namehiddenforexample(int param_1)

{
  int iVar1;
  uint *puVar2;
  int iVar3;
  int iVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  int iVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  uint uVar12;
 
  puVar2 = (uint *)(param_1 + 0x1c);
  uVar10 = *(uint *)(param_1 + 8);
  uVar11 = *(uint *)(param_1 + 0xc);
  uVar12 = *(uint *)(param_1 + 0x10);
  uVar9 = *(uint *)(param_1 + 0x14);
  uVar5 = *puVar2;
  iVar6 = *(int *)(param_1 + 0x20);
  iVar7 = *(int *)(param_1 + 0x24);
  iVar8 = *(int *)(param_1 + 0x28);
  iVar1 = *(int *)(param_1 + 0x2c);
  iVar3 = *(int *)(param_1 + 0x30);
  iVar4 = *(int *)(param_1 + 0x34);
  *puVar2 = (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) << 1 |
            (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) >> 0x1f;
  *(uint *)(param_1 + 0x20) =
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) << 1 |
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) >> 0x1f;
  *(uint *)(param_1 + 0x24) =
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) << 1 |
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) >> 0x1f;
  *(uint *)(param_1 + 0x28) =
       (*puVar2 ^ *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48))
       << 1 | (*puVar2 ^ *(uint *)(param_1 + 0x28) ^
              *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48)) >> 0x1f;
  *(uint *)(param_1 + 0x2c) =
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) << 1 |
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) >> 0x1f;
  *(uint *)(param_1 + 0x30) =
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) << 1 |
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) >> 0x1f;
  *(uint *)(param_1 + 0x34) =
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) << 1 |
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) >> 0x1f;
  *(uint *)(param_1 + 0x38) =
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) << 1 |
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) >> 0x1f;
  *(uint *)(param_1 + 0x3c) =
       (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x44) ^ *puVar2)
       << 1 | (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^
              *(uint *)(param_1 + 0x44) ^ *puVar2) >> 0x1f;
  *(uint *)(param_1 + 0x40) =
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) << 1 |
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) >> 0x1f;
  *(uint *)(param_1 + 0x44) =
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) << 1 |
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) >> 0x1f;
  *(uint *)(param_1 + 0x48) =
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) << 1 |
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) >> 0x1f;
  *(uint *)(param_1 + 0x4c) =
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) << 1 |
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) >> 0x1f;
  *(uint *)(param_1 + 0x50) =
       (*(uint *)(param_1 + 0x44) ^ *(uint *Yes we still fail at the same error but it seems that now it fails at a DIFFERENT SPARE area with a code I have NOT seen before. So that means we just got to do what we did before except figure out what byte needs to be set to 0(or something else) and just keep going until we implement every hidden code)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) << 1 |
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) >> 0x1f;
  uVar5 = *(int *)(param_1 + 0x18) + (uVar10 >> 0x1b | uVar10 << 5) +
          (uVar9 ^ uVar11 & (uVar12 ^ uVar9)) + 0x5a827999 + uVar5;
  uVar5 = uVar11 << 0x1e | uVar11 >> 2;
  uVar5 = uVar10 << 0x1e | uVar10 >> 2;
  *(uint *)(param_1 + 0x54) =
       (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^ *puVar2 ^ *(uint *)(param_1 + 0x34))
       << 1 | (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^
              *puVar2 ^ *(uint *)(param_1 + 0x34)) >> 0x1f;
  uVar5 = uVar9 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar12 ^ uVar10 & (uVar5 ^ uVar12)) + 0x5a827999
          + iVar6;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar12 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          iVar7;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          iVar8;
  *(uint *)(param_1 + 0x58) =
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) << 1 |
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          iVar1;
  *puVar2 = (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) << 1 |
            (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          iVar3;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x20) =
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) << 1 |
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          iVar4;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x38);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x3c);
  *(uint *)(param_1 + 0x24) =
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) << 1 |
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x40);
  *(uint *)(param_1 + 0x28) =
       (*puVar2 ^ *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48))
       << 1 | (*puVar2 ^ *(uint *)(param_1 + 0x28) ^
              *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x44);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x48);
  *(uint *)(param_1 + 0x2c) =
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) << 1 |
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x4c);
  *(uint *)(param_1 + 0x30) =
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) << 1 |
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x50);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x54);
  *(uint *)(param_1 + 0x34) =
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) << 1 |
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x58);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *puVar2;
  *(uint *)(param_1 + 0x38) =
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) << 1 |
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x20);
  *(uint *)(param_1 + 0x3c) =
       (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x44) ^ *puVar2)
       << 1 | (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^
              *(uint *)(param_1 + 0x44) ^ *puVar2) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x24);
  *(uint *)(param_1 + 0x40) =
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) << 1 |
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 & (uVar5 ^ uVar5)) + 0x5a827999 +
          *(int *)(param_1 + 0x28);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x44) =
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) << 1 |
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x2c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x30);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x34);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x48) =
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) << 1 |
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x38);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x4c) =
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) << 1 |
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x3c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x40);
  *(uint *)(param_1 + 0x50) =
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) << 1 |
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x44);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x54) =
       (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^ *puVar2 ^ *(uint *)(param_1 + 0x34))
       << 1 | (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^
              *puVar2 ^ *(uint *)(param_1 + 0x34)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x48);
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x4c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x58) =
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) << 1 |
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x50);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *puVar2 = (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) << 1 |
            (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x54);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x20) =
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) << 1 |
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x58);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 + *puVar2;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x24) =
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) << 1 |
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x20);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x24);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x28) =
       (*puVar2 ^ *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48))
       << 1 | (*puVar2 ^ *(uint *)(param_1 + 0x28) ^
              *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x28);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x2c) =
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) << 1 |
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x2c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x30) =
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) << 1 |
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x30);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x34);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x34) =
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) << 1 |
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0x6ed9eba1 +
          *(int *)(param_1 + 0x38);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x3c);
  *(uint *)(param_1 + 0x38) =
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) << 1 |
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x40);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x44);
  *(uint *)(param_1 + 0x3c) =
       (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x44) ^ *puVar2)
       << 1 | (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^
              *(uint *)(param_1 + 0x44) ^ *puVar2) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x48);
  *(uint *)(param_1 + 0x40) =
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) << 1 |
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x4c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x50);
  *(uint *)(param_1 + 0x44) =
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) << 1 |
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x54);
  *(uint *)(param_1 + 0x48) =
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) << 1 |
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x58);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *puVar2;
  *(uint *)(param_1 + 0x4c) =
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) << 1 |
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x20);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x50) =
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) << 1 |
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x24);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x28);
  *(uint *)(param_1 + 0x54) =
       (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^ *puVar2 ^ *(uint *)(param_1 + 0x34))
       << 1 | (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^
              *puVar2 ^ *(uint *)(param_1 + 0x34)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x2c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x30);
  *(uint *)(param_1 + 0x58) =
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) << 1 |
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x34);
  *puVar2 = (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) << 1 |
            (*(uint *)(param_1 + 0x50) ^ *puVar2 ^
            *(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x3c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x38);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x20) =
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) << 1 |
       (*(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x20) ^
       *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x40)) >> 0x1f;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x3c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x40);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x24) =
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) << 1 |
       (*(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x24) ^
       *(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x44)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x44);
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) +
          (uVar5 & uVar5 | uVar5 & (uVar5 ^ uVar5)) + 0x8f1bbcdc + *(int *)(param_1 + 0x48);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x28) =
       (*puVar2 ^ *(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48))
       << 1 | (*puVar2 ^ *(uint *)(param_1 + 0x28) ^
              *(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x48)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x4c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x50);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x2c) =
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) << 1 |
       (*(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x2c) ^
       *(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x4c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x54);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x30) =
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) << 1 |
       (*(uint *)(param_1 + 0x24) ^ *(uint *)(param_1 + 0x30) ^
       *(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x50)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x58);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 + *puVar2;
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x34) =
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) << 1 |
       (*(uint *)(param_1 + 0x28) ^ *(uint *)(param_1 + 0x34) ^
       *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x54)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x20);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x38) =
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) << 1 |
       (*(uint *)(param_1 + 0x2c) ^ *(uint *)(param_1 + 0x38) ^
       *(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x58)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x24);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x28);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x3c) =
       (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x44) ^ *puVar2)
       << 1 | (*(uint *)(param_1 + 0x30) ^ *(uint *)(param_1 + 0x3c) ^
              *(uint *)(param_1 + 0x44) ^ *puVar2) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x2c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x40) =
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) << 1 |
       (*(uint *)(param_1 + 0x34) ^ *(uint *)(param_1 + 0x40) ^
       *(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x20)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x30);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x34);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x44) =
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) << 1 |
       (*(uint *)(param_1 + 0x38) ^ *(uint *)(param_1 + 0x44) ^
       *(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x24)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x38);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x48) =
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) << 1 |
       (*(uint *)(param_1 + 0x3c) ^ *(uint *)(param_1 + 0x48) ^
       *(uint *)(param_1 + 0x50) ^ *(uint *)(param_1 + 0x28)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x3c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x40);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x4c) =
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) << 1 |
       (*(uint *)(param_1 + 0x40) ^ *(uint *)(param_1 + 0x4c) ^
       *(uint *)(param_1 + 0x54) ^ *(uint *)(param_1 + 0x2c)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x44);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x50) =
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) << 1 |
       (*(uint *)(param_1 + 0x44) ^ *(uint *)(param_1 + 0x50) ^
       *(uint *)(param_1 + 0x58) ^ *(uint *)(param_1 + 0x30)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x48);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x4c);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x54) =
       (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^ *puVar2 ^ *(uint *)(param_1 + 0x34))
       << 1 | (*(uint *)(param_1 + 0x48) ^ *(uint *)(param_1 + 0x54) ^
              *puVar2 ^ *(uint *)(param_1 + 0x34)) >> 0x1f;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x50);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  uVar5 = uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
          *(int *)(param_1 + 0x54);
  uVar5 = uVar5 * 0x40000000 | uVar5 >> 2;
  *(uint *)(param_1 + 0x58) =
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) << 1 |
       (*(uint *)(param_1 + 0x4c) ^ *(uint *)(param_1 + 0x58) ^
       *(uint *)(param_1 + 0x20) ^ *(uint *)(param_1 + 0x38)) >> 0x1f;
  *(uint *)(param_1 + 8) =
       *(int *)(param_1 + 8) +
       uVar5 + (uVar5 >> 0x1b | uVar5 * 0x20) + (uVar5 ^ uVar5 ^ uVar5) + 0xca62c1d6 +
       *(int *)(param_1 + 0x58);
  *(uint *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + uVar5;
  *(uint *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) + (uVar5 * 0x40000000 | uVar5 >> 2);
  *(uint *)(param_1 + 0x14) = *(int *)(param_1 + 0x14) + uVar5;
  *(uint *)(param_1 + 0x18) = *(int *)(param_1 + 0x18) + uVar5;
  return;
}

If you guessed "This is a SHA1 Encryption Transforming scheme function" then congrats you are right.

Seriously what the FUCK. You can start to see WHY I was away for so long.

Now before I talk more about it I should probally say HOW reverse engineering works because it is intresting.
When you compile a program. Lets say a SIMPLE C program
Code: 
#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");  // Actually do the work here
}
It turns into MACHINE code. This is the LOWEST level form of code Which is ALL a computer can understand. Every instruction your computer runs is in MACHINE code. Your computers kernel of course TAKES your code when you run the program and puts it in memory and RUNS that instruction.
(Most code that needs to be execuatable by a kernel has restrictions and has to be desgined to communicate WITH the kernel in the name of security and multitasking. This is a VERY surface level explination of it)

Now the thing is WITH machine code lets see what it looks like
1769984354414.png
(This is not what our Hello world machine code is. Its just a random example I got on google. But the relevance is there)
Well thats useless to us...

Well what can we do to MAKE that more readable. Well we can do what most operating systems do and view it as HEX.

Hex is just a way of intrepeting numbers.
If you do not know HOW hex works we need to understand WHY hex is used.
Hex is used in order to use as LITTLE seperate charcteres as possiable. every 0 and every blank is ALOT harder to humanily read and ALOT more DATA for computers to intrepet.

Basically hex works by having 0-9 acting as normal numbers BUT when it comes to repersenting the number 10 instead of having a NEW charcterpoint(10) it is repersented as a LETTER going from A to F. This makes it so that we can store ALOT more possiable values within ONE piece of data(Although at the end of the day its still just binary)
So for example
10 would be 0x0A, 11 would be 0x0B, 12 would be 0x0C and you get the point. Eventually when we reach past F we finally create ANOTHER character point then starting at "0xF1"
Congraulations you now understand HEX. It becomes ALOT more simpler once you understand WHY its the way it is...
All it is simply just a way to CONSERVE the amount of charcters printed on screen. When you open a HEX editor the data is not litterally in hex its in binary. Its just that the operating system and hex editor intrepet it as HEX because its easier for us to view...

Anyways WITH that we can now get a BETTER look AT what our compiled program does and see what itlooks like. Drumroll please.
Yeah ummm... its still useless...
1769985032977.png

So what now? Well we can LEARN what exactly machine code is.
Again that Hex is just a easier way on the eyes to view binary... So when I say lets say 0x64 technically if you want to be a smartass YES the computer DEEP down not even a lowest level on the software side views it 0x64 as 1s and 0s...

Now we have to understand. Machine code is at its core, not meant to be read by humans and ill get in HOW we properly read it in a minute.
For example if you see "000010" or 0x20 in hex is acutally the command to tell the processor to goto a memory address. These labels are known as Opcodes
(this depends on the archtecture. On MIPS its this way but on x86 its differnet. This is why programs need to be compiled for different platforms not including the reason of operating system difference)
Now there are lists showing WHAT each binary code does.

People go and NAME these instructions giving them NAMES
1769985551416.png
so for example that 0x20.. the offical name for it would be (JMP) or JUMP. These codes all have different names that when put together makes the language known as ASSEMBLY.

Yes all assembly is is just a WAY to intrepet machine code. Its not really a SEPERATE language in the sense of C or C++. Think of it like a HUMAN dictionary of what Machine code instructions mean.
So if you were to get EVERY Opcode or Machine code instruction and translate them into assembly by just following what each definition MEANS realtive to the processor. We would get
1769986530954.png
(This is human written assembler rather than code made from a C compiler, REAL c code would have NO direct functions names and would be a lot less human readable than this..... Somehow)

There are programs that AUTOMATICALLY conver that machine code TO assembly. These are called as patronizing as im putting this "Reverse engineering software"
These softwares can even intrepet that assembly code as basic C like psudocode
1769989810240.pngthe LOWEST form of code that is
Now its important to know that because we used a COMPILER to compile a program (Not that the attached screenshot is from the hello world program) that means that

  1. Variable names are removed. ALL function names need to be figured out manually
  2. This is the MACHINE efficent version of what the code does. Not the HUMAN version. So some things are harder
  3. Sometimes the data is WRONG or needs retyping. Like a string "INIT" may be repersented as hex symbol rather than a string and you have to manually rephrase it
  4. You can NOT generally recompile code given. Its just for UNDERSTANDING.
  5. Alot of other things that make it REALLY annoying
So after all of that I was then left with figuring out WHAT is causing the error now with my NEW insight. And after days of GDB testing, automation script making, and brute forcing I have finally gotten it cracked.

Now in case you don't now in a NAND there is typically PAGES. pages to most things are irrelevant but pretty much its a given DEFINED amount of bytes.
For our nand a page consists of
  1. 2048 MAIN bytes of dataAnd guess what. I did
  2. 64 extra bytes for data correction and checksum calculation
Now what is failing is that its trying to CHECK the checksum of the blocks from the DUMPED nand from the shady corners of the Russian internet I used to get a dump of this tvs NAND. And its failing.
1769990799611.png

This is concerning and could mean that the DUMP could be BAD which if thats the case than it means we are FUCKED. But it also could mean that our DMA handler(or direct memory access) which is how my QEMU fork emulates the NAND and sends data is returning stuff in a order that is wrong.

So here is what I did.

I want to see if I can RECREATE what the NAND is doing in ANOTHER language that i can run so I can better understand HOW the ECC/checksum works.
So I went and remade the ENTIRE NAND CHECKSUM function in luaJIT as a automation script

=== Page 256 ECC Analysis ===
Metadata: 00 01 00 00 FF FF 50 00
Calculated ECC: 2A 00 58
Stored ECC: 29 00 98
✗ ECC MISMATCH
Diff: 03 00 C0
[/CODE]
(this is ONE of the reads that i randomly took from what the TV bootloader acutally reads)
Now I want to say something.
Bytes 1-2Padding and for linux(Linux does a SIMPLE bad block checking where it just scans the FIRST byte of the spare area and see if its FF)
Byte 3 UnknownREMEMBER THIS LATER
Bytes 4-6Unknown
Byte 7-8Page Number
Last byte UnknownREMEMBER THIS LATER

Now something to note that ALMOST every byte the bootloader scans has a INCORRECT checksum of exactly ONE, just simply ONE byte off in its checksum that is causing it. Its TO CONCIDENTIAL. Which means its likely HOW the data is delieved by qemu that is causing the error.

So here is what I did. I wrote a automation script to get EVERY pages OOBs information and sorted through the THOUSANDS and THOUSANDS and I noticed something. And here is what I found.

MOST OOB/PAGEs had the first 3 values as "FF FF FF"

HOWEVER

Almost EVERYTHING OOB the bootloader reads has the THIRD BYTE or the LAST byte as 61(FF FF 61). NOTICE THAT... So why is that?
Well on REAL hardware when you read via DMA its acutally a INTERNAL code in the NAND that sets stuff like WRITE lock.
Something that a EXTERNAL NAND PROGRAMMER MIGHT... oh I don't know. IGNORE...(Gosh darnit russians I thought you were GOOD at pirating and dumping stuff)
looking at any bytes that look off All of them have BYTE 40 as .... 1.. and its a offset as one.
Perhaps on real hardware that 61 is acutally a STATUS to the hardware like a WRITE lock that then gets CLEARED when read by DMA... and guess what... Setting that 40 bit to 0...
✓ ECC MATCH

So that means that the THIRD or last byte is acutally a CODE that we need to handle by setting a seperate byte to 0. So lets go back to QEMU

1769993996130.png
Recompile it and guess what. IT GOT FURTHER
1769994027052.png
(Failing OOB check) OOB: FF FF 85 FF
Yes we still fail at the same error but it seems that now it fails at a DIFFERENT SPARE area with a code I have NOT seen before. So that means we just got to do what we did before except figure out what byte needs to be set to 0(or something else) and just keep going until we implement every hidden code
1769994329919.png
I CAN SAY THOUGH THAT ITS GOTTEN SO FAR THAT ITS MOUNTED MOST OF THE PARTITIONS.
1770051888440.png

Now what have I done right now?
Well Ive used grok and me to work up a quick "Brute force script" so I can see what bytes would make this VALID... and also the ability to scan the nand to see our current algorhythm and HOW effectively we can pass the checksum
1770052115754.png
And you know what? Its pretty damn close.
But not close enough JUST yet...
 
Last edited:
ProudSkibidiTolietAryan said:
When I said "Oh the bootloader? That has gotten further now.'
I was wrong. VERY wrong. as it turns out that was NOT the case. I just made it crash EARLIER instead of further from before.
Click to expand...
This movie has better plot twists than anything Hollywood has made.


I wish I were able to contribute. But since this is all far beyond my meager coding skills, I'm just along for the ride. Don't give up, Aryan Toilet man! Don't let this shitty TV beat you!
 
seri0us said:
Other than the printing bug how does she like it so far?
Click to expand...
She's going okay with Linux. I've got her on KDE since it's pretty Windows like. It's kind of frustrating though, despite her regularly using computers for 35+ years, she's not particularly proficient with them. So for instance she was having trouble location a file she'd downloaded. I've got the task manager set up real simple with just Dolphin, Chromium and OnlyOffice pinned - it's more simple than her Windows 11 taskbar without Copilot and other shit. But asking her to "click on the blue folder icon in the bottom left" got her a bit flustered at which icon to click on.

But before I installed Linux on her computer I created an image of her Windows install and told her it's very straightforward for me to restore Windows to the way it was set up before. She's been on Linux for about a month, so I'm pretty sure she'll stick with it.
 
Tremolo said:
Linux From Scratch is dropping sysvinit support
Click to expand...
polakrobak99 said:
This is so retarded. The most autistic Linux distro stops being autistic because of GNOME/KDE reqs? Who the fuck is installing a DE on LFS? Also, you can always use elogind like Devuan &a, this has been solved long ago. So stupid.
Click to expand...
I did. I had Gnome 1.x running on LFS. I remember printing out the book in my university's computer lab, and going into the TA room to discretely grab more printer paper and hope my boss didn't notice that I was printing out a book. It took a week to setup LFS. Then I accidentally screwed up a bunch of permissions and had to built it again. This time it took 2~3 days. I think this was all on a Pentium III 667Mhz.

LFS was how I learned everything about Linux. I had a text file with all my ./configure flags and watched FreshMeat for new packages. I ran that thing for almost two who semesters before I went back to a real distro and I have never been more appreciative of package management.

LFS is what taught me the skills I needed to take jobs doing everything from embedded systems to big data center migration contracts.

I'm glad it's still around, and seems more active than Slackware (my first distro). I can honestly understand why a maintainer would target systemd if they only had time for one init system, despite how garbage it is. Maybe someone will fork and maintain a runit version.

Despite the change, I imagine it's still a valuable tool in understanding how Linux distributions are put together.
 
You must log in or register to reply here.
Back
Top Bottom