const Discord = require('discord.js');
const client = new Discord.Client();

client.on('ready', () => {
  console.log(`Logged in as ${client.user.tag}!`);
  console.log(`Currently in ${client.guilds.cache.size} servers.`);
});

client.login('your-bot-token');

import os

# Get the current directory
current_dir = os.getcwd()

# Loop through each file in the current directory
for filename in os.listdir(current_dir):

    # Check if the file name starts with a number followed by a period and a space
    if filename[0].isdigit() and filename[1] == '.' and filename[2] == ' ':
        
        # Remove the number, period, and space from the file name
        new_filename = filename[3:]
        
        # Rename the file
        os.rename(os.path.join(current_dir, filename), os.path.join(current_dir, new_filename))

public class UserService {

  private UserRepository userRepository;

  public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
  }

  public User getUserById(long id) {
    try {
      return userRepository.getUserById(id);
    } catch (Exception e) {
      // Log the exception here
      System.out.println("An error occurred while fetching the user: " + e.getMessage());
      return null;
    }
  }
}

public class UserRepository {

  public User getUserById(long id) throws Exception {
    // Database query to fetch the user
    if (id < 0) {
      throw new Exception("Invalid user id");
    }
    // Return the user object
    return new User(id, "John Doe");
  }
}

public class User {

  private long id;
  private String name;

  public User(long id, String name) {
    this.id = id;
    this.name = name;
  }

  public long getId() {
    return id;
  }

  public String getName() {
    return name;
  }
}

public static void enu2ecefCov(GMatrix ecefCov, GMatrix enuCov, LLA refLLA) {
    double lambda = refLLA.longitude;
    double phi = refLLA.latitude;
    
    GMatrix R = new GMatrix(6, 6);
    GMatrix Rt = new GMatrix(6, 6);
    GMatrix tmp1 = new GMatrix(6, 6);
    GMatrix tmp2 = new GMatrix(6, 6);
    
    R.setElement(0, 0, -Math.sin(lambda));
    R.setElement(0, 1, -Math.sin(phi)*Math.cos(lambda));
    R.setElement(0, 2, Math.cos(phi)*Math.cos(lambda));
    R.setElement(1, 0, Math.cos(lambda));
    R.setElement(1, 1, -Math.sin(phi)*Math.sin(lambda));
    R.setElement(1, 2, Math.cos(phi)*Math.sin(lambda));
    R.setElement(2, 0, 0);
    R.setElement(2, 1, Math.cos(phi));
    R.setElement(2, 2, Math.sin(phi));
    R.setElement(3, 3, -Math.sin(lambda));
    R.setElement(3, 4, -Math.sin(phi)*Math.cos(lambda));
    R.setElement(3, 5, Math.cos(phi)*Math.cos(lambda));
    R.setElement(4, 3, Math.cos(lambda));
    R.setElement(4, 4, -Math.sin(phi)*Math.sin(lambda));
    R.setElement(4, 5, Math.cos(phi)*Math.sin(lambda));
    R.setElement(5, 3, 0);
    R.setElement(5, 4, Math.cos(phi));
    R.setElement(5, 5, Math.sin(phi));

    Rt.transpose(R);
    tmp1.mul(enuCov, R);
    ecefCov.mul(Rt, tmp1);
}

import simd

private func test() {
    let screenWidth: Int = 256
    let screenHeight: Int = 240
    let pixelBufferPtr = UnsafeMutableBufferPointer<BGRA>.allocate(capacity: screenWidth * screenHeight)
    let runCount = 1000
    let start = Date.now
    for _ in 0 ..< runCount {
        var index = 0
        var palletIndex = 0
        let palletCount = BGRAPallet.count
        while index < pixelBufferPtr.count {
            let bgra = BGRAPallet[palletIndex]
            let bgraVector = simd_uint4(bgra.blue, bgra.green, bgra.red, bgra.alpha)
            let maxCount = min(pixelBufferPtr.count - index, 4)
            let pixelBuffer = pixelBufferPtr.baseAddress! + index
            pixelBuffer.storeBytes(of: bgraVector, as: simd_uint4.self)
            palletIndex += 1
            if palletIndex == palletCount {
                palletIndex = 0
            }
            index += maxCount
        }
    }
    let elapsed = Date.now.timeIntervalSince(start)
    print("Average time per run: \((Int(elapsed) * 1000) / runCount) ms")
}


//if for some reason your system doesnt support simd_uint4, you can try the following: 
// private func test() {
//     let screenWidth: Int = 256
//     let screenHeight: Int = 240
//     let pixelBufferPtr = UnsafeMutableBufferPointer<BGRA>.allocate(capacity: screenWidth * screenHeight)
//     let runCount = 1000
//     let start = Date.now
//     for _ in 0 ..< runCount {
//         let pixelBuffer = pixelBufferPtr.baseAddress!
//         let pixelBufferCount = pixelBufferPtr.count
//         let palletCount = BGRAPallet.count
//         var palletIndex = 0
//         for i in stride(from: 0, to: pixelBufferCount, by: 4) {
//             let bgra = BGRAPallet[palletIndex]
//             pixelBuffer[i] = bgra
//             pixelBuffer[i + 1] = bgra
//             pixelBuffer[i + 2] = bgra
//             pixelBuffer[i + 3] = bgra
//             palletIndex += 1
//             if palletIndex == palletCount {
//                 palletIndex = 0
//             }
//         }
//     }
//     let elapsed = Date.now.timeIntervalSince(start)
//     print("Average time per run: \((Int(elapsed) * 1000) / runCount) ms")
// }

function printHeap(heap, index, level) {
    if (index >= heap.length) {
        return;
    }
    console.log("  ".repeat(level) + heap[index]);
    printHeap(heap, 2 * index + 1, level + 1);
    printHeap(heap, 2 * index + 2, level + 1);
}

//You can call this function by passing in the heap array and the index of the root node, which is typically 0, and level = 0.

let heap = [3, 8, 7, 15, 17, 30, 35, 2, 4, 5, 9];
printHeap(heap,0,0)