trait ATrait {
    fn a(&mut self) -> &mut A{
        self.a()
    }
    fn b(&mut self) -> &mut i64{
        return self.a().b()
    }
}
struct A {
    b: i64
}
impl ATrait for A {
    fn a(&mut self) -> &mut A{
        self
    }
    fn b(&mut self) -> &mut i64{
        &mut self.b
    }
}

struct B {
    a: A,
    c: i64
}

impl ATrait for B{
    fn a(&mut self) -> &mut A{
        self.a.a()
    }
}



fn main() {
    let mut b: B = B{
        a: A {b: 2},
        c: 3
    };
    println!("{}", b.b());
}

# Needs array or use -s to slurp

# Just making sure it's an array, or object
. | iterables |
# This won't error (I want to use halt_error in the future, but idk how to convert this into an error.)
# So if your output is empty, that's why

[.[] | del(.[] | select(type == "array" or type == "object"))] |
([.[] | keys[]] | unique | map({(.): null}) | add) as $uniqueKeys |
($uniqueKeys | keys_unsorted | @csv),
($uniqueKeys + .[] | [.[]] | @csv)

//===============Header File==================
#include <iostream>
#include <sstream> //stringbuf
#include <utility> //exchange

//Couple rules:
//Characters given through the getter functions have to be removed from the buffer.
    //This is so that bufferEmpty() == buffer.in_avail() > 0 basically always.
    //skipWhitespace doesn't remove the text from the buffer, but it does return the number of characters.
//nextWord will trim whitespace before the word
//nextInt will trim non-numbers before the number
//hasNextInt and hasNextWord will trim the whitespace. If you think you need it, you should get nextWhitespace before doing any of those.
//Whitespace after a word or an int is left on the buffer.
//nextWhitespace will (get and) remove whitespace until the end of the line, including the newline character, but stops before the next line.
    //nextWhitespace won't read the next line when called before the end of the line, and it won't prompt the user for the next line if interactive.
        //If nextWhitespace is called after reading the end of the line, then it will read a new line into the buffer, which will prompt the user.
    //It acts like nextLine, but if there's something non-whitespace on the current line it stops there.
class Scanner {
    public:
        std::stringbuf buffer;
        std::istream& input;
        
        Scanner(std::istream& in = std::cin) : buffer(), input(in) {}
        
    //Buffer debugging
        bool fillBuffer();
    
        bool bufferEmpty();
        void printBufferEmpty();
        std::string getBuffer();
        size_t bufferLength();
        void printBufferStats();
    
    //Int
        bool hasNextInt();
        int nextInt();
    
    //Word
        bool hasNextWord();
        std::string nextWord();
    
    //Line
        bool hasNextLine();
    
    //Whitespace
        size_t skipWhitespace();    //Prob should be private, but I don't believe in that private shit.
        bool hasNextWhitespace();
        std::string nextWhitespace();
        std::string nextWhitespaceAll();
        std::string nextLine();
};

//===============Source File==================
bool Scanner::fillBuffer() {    //Returns if it had to get the next line from the input.
    const bool badInput = input.eof() || input.bad();
    const bool shouldFillBuffer = bufferEmpty() && !badInput;
    if (shouldFillBuffer) {
        std::string line;
        if (std::getline(input, line)) {
            buffer.str(buffer.str() + line + "\n");
        }
    }
    return shouldFillBuffer;
}

bool Scanner::bufferEmpty(){
    return buffer.str() == "";
}
void Scanner::printBufferEmpty(){
    std::cout << "The buffer is " << (bufferEmpty()? "" : "not") << " empty." << std::endl;
}

std::string Scanner::getBuffer(){
    return buffer.str();
}
size_t Scanner::bufferLength(){
    return buffer.str().length();
}
void Scanner::printBufferStats(){
    if(bufferEmpty()){
        std::cout << "The buffer is \"\"" << std::endl;
        return;
    }
    std::cout << "The length of the buffer is " << bufferLength() << std::endl;
    if(buffer.sgetc() == '\r'){
        std::cout << "The buffer is \\r\\n" << std::endl;
    }else if(buffer.sgetc() == '\n'){
        std::cout << "The buffer is \\n" << std::endl;
    }
}

bool Scanner::hasNextInt() {
    return hasNextWord() && (std::isdigit(buffer.sgetc()) || buffer.sgetc() == '-');
}

int Scanner::nextInt() {
    if (!hasNextInt()) {   //Will fill the buffer if not filled. Will also trim whitespace.
        return 0;
    }
    
    std::string num;
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && (std::isdigit(buffer.sgetc()) || buffer.sgetc() == '-')) {
        num += buffer.sbumpc();
        ++charactersRead;
    }
    buffer.str(buffer.str().erase(0, charactersRead));
    return std::stoi(num);
}

bool Scanner::hasNextWord() {
    nextWhitespaceAll();
    return buffer.in_avail() > 0;
}

std::string Scanner::nextWord() {
    if (!hasNextWord()) {   //Will fill the buffer if not filled. Will also trim whitespace.
        return "";
    }
    
    std::string word;
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && !std::isspace(buffer.sgetc())) {
        word += buffer.sbumpc();
        ++charactersRead;
    }
    buffer.str(buffer.str().erase(0, charactersRead));
    return word;
}

bool Scanner::hasNextLine() {
    return (!bufferEmpty()) || fillBuffer();
}

size_t Scanner::skipWhitespace() {   //Returns characters read
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && std::isspace(buffer.sgetc())) {
        buffer.sbumpc();
        ++charactersRead;
    }
    return charactersRead;
}
bool Scanner::hasNextWhitespace(){
    fillBuffer();
    return buffer.in_avail() > 0 && std::isspace(buffer.sgetc());
}
std::string Scanner::nextWhitespace() {
    if (!hasNextWhitespace()) {   //Will fill the buffer if not filled
        return "";
    }
    const size_t charactersRead = skipWhitespace();
    std::string whitespace = buffer.str().substr(charactersRead);
    buffer.str(buffer.str().erase(0, charactersRead));
    return whitespace;
}
std::string Scanner::nextWhitespaceAll(){
    std::string whitespace;
    while(hasNextWhitespace()){
        std::string gottenWhiteSpace = nextWhitespace();
        whitespace += gottenWhiteSpace;
    }
    return whitespace;
}
std::string Scanner::nextLine(){
    if (!hasNextLine()) {
        return "";
    }
    
    fillBuffer();
    //Swap out the old buffer with an empty buffer, and get the old buffer as a variable.
    std::string line = std::exchange(buffer, std::stringbuf()).str();
    
    //Remove the newline.
    if(line[line.length() - 1] == '\n' || line[line.length() - 1] == '\r' ) line.pop_back();
    if(line[line.length() - 1] == '\r' || line[line.length() - 1] == '\n' ) line.pop_back();
    return line;
}


//=================Word and Int test=================
while(bruh.hasNextInt() || bruh.hasNextWord()){
    std::cout << "started loop" << std::endl;
    if(bruh.hasNextInt()){
        std::cout << "Int: " << bruh.nextInt() << " " << std::endl;
    }else{
        std::cout << "Word: " << bruh.nextWord() << " " << std::endl;
    }
    bruh.nextWhitespace();
}
//===================Line test======================
for(int count = 1; bruh.hasNextLine(); ++count){
    std::string line = bruh.nextLine();
    std::cout << "Line " << count << ": " << line << std::endl;
}

#!/bin/bash

# Recursively find all .svelte files in the current directory and its subdirectories
find . -type f -name "*.svelte" -o -name "*.html" -o -name "*.htm" | while read file; do
        # Replace all h1 tags with the specified format
        sed -i 's/<h1>\(.*\)<\/h1>/<h1 id="\1">\1<\/h1>/g' "$file"
        # Replace all h2 tags with the specified format
        sed -i 's/<h2>\(.*\)<\/h2>/<h2 id="\1">\1<\/h2>/g' "$file"
        # Remove whitespace from the id attribute value
        for i in {0..10} ; do
                sed -i 's/\(id="[^"]*\)\W\([^"]*"\)/\1\2/g' "$file"
        done
done

function filePath(file){
  let folders = file.getParents();
  const parents = [];

  function makePathString(folderArray){
    let path = "";
    folderArray.forEach((folder)=>{
      path += "/" + folder.getName();
    });
    return path;
  }
  
  while (folders.hasNext()) {
    const folder = folders.next(); //This should hopefully remove that folder from the iterator
    parents.unshift(folder);
  }

  return makePathString(parents);
}

function myFunction() {
  const myEmail = Session.getEffectiveUser().getEmail();
  Logger.log("My email is " + myEmail);
  // Log the name of every file in the user's Drive.
  var fileIterator = DriveApp.getFiles();
  const files = []; //List of [File, size] entries
  const filesMaxSize = 10;
  while (fileIterator.hasNext()) {
    var file = fileIterator.next();

    const owner = file.getOwner();

    //Only files I own
    if((!(owner)) || (!(owner.getEmail)) || owner.getEmail() != myEmail){
      continue;
    }

    const entry = [file, file.getSize()];

    function slideUp(arr, index){
      //Let's keep sliding it up so we don't have to sort it at the end.
      for(let i = index; i > 0; --i){ //Stops at 1
        const nextFile = arr[i-1];

        if(nextFile[1] > entry[1]){
          break;
        }else{
          //Swap with the next file to slide the file up
          const temp = arr[i];
          arr[i] = arr[i - 1];
          arr[i - 1] = temp;
        }
      }
    }

    if(files.length < filesMaxSize){
      files.push(entry);

      slideUp(files, files.length - 1);
    }else{
      if(entry[1] > files[files.length - 1][1]){ //If it's bigger than the smallest file in the list.
        files[files.length - 1] = entry;  //Replace the smallest file

        slideUp(files, files.length - 1); //Slide it up
      }
    }
  }

  for(let i = 0; i < filesMaxSize; ++i){
    const file = files[i][0];
    const size = files[i][1];
    Logger.log(size + "\t" + filePath(file) + "/" + file.getName() + "\t" + file.getOwner().getName());
  }
}