def busca_binaria(lista, alvo):
    esquerda, direita = 0, len(lista) - 1
    while esquerda <= direita:
        meio = (esquerda + direita) // 2
        if lista[meio] == alvo:
            return meio
        elif lista[meio] < alvo:
            esquerda = meio + 1
        else:
            direita = meio - 1
    return -1

const express = require('express');
const app = express();
app.use(express.json());
let usuarios = [];
app.post('/usuarios', (req, res) => {
    const { id, nome } = req.body;
    usuarios.push({ id, nome });
    res.status(201).json({ mensagem: 'Usuário criado', usuario: { id, nome } });
});
app.listen(3000, () => console.log('Servidor rodando na porta 3000'));

#include 
void quickSort(int arr[], int baixo, int alto) {
    if (baixo < alto) {
        int pivo = arr[alto];
        int i = baixo - 1;
        for (int j = baixo; j < alto; j++) {
            if (arr[j] <= pivo) {
                i++; std::swap(arr[i], arr[j]);
            }
        }
        std::swap(arr[i + 1], arr[alto]);
        int pi = i + 1;
        quickSort(arr, baixo, pi - 1);
        quickSort(arr, pi + 1, alto);
    }
}

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
public class JWTUtil {
    private static final String SEGREDO = "chave_secreta_agatha";
    public static String gerarToken(String usuario) {
        return Jwts.builder()
            .setSubject(usuario)
            .signWith(SignatureAlgorithm.HS256, SEGREDO)
            .compact();
    }
    public static void main(String[] args) {
        System.out.println(gerarToken("admin"));
    }
}

pragma solidity ^0.8.0;
contract Registro {
    mapping(address => uint) public saldos;
    event Transferencia(address de, address para, uint valor);
    function transferir(address para, uint valor) public {
        require(saldos[msg.sender] >= valor, "Saldo insuficiente");
        saldos[msg.sender] -= valor;
        saldos[para] += valor;
        emit Transferencia(msg.sender, para, valor);
    }
}

fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
main = print (fib 10)

function multiplicar_matrizes(A, B)
    m, n = size(A)
    n, p = size(B)
    C = zeros(m, p)
    for i in 1:m
        for j in 1:p
            for k in 1:n
                C[i,j] += A[i,k] * B[k,j]
            end
        end
    end
    return C
end

use std::thread;
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread: {}", i);
        }
    });
    handle.join().unwrap();
}

{
    "email": "[email protected]",
    "senha": "senha_segura_123"
}

{
    "mensagem": "Gere um script Python para calcular fatorial",
    "usuario_id": 1,
    "modo_resposta": "tecnico_avancado"
}

{
    "descricao": "Robô futurista em um deserto",
    "modelo_imagem": "Agatha_Epic_Realism_XL",
    "resolucao": "1024x1024"
}

{
    "servidor_id": 1,
    "metricas": ["cpu", "memoria", "disco"]
}

def binary_search(list, target):
    left, right = 0, len(list) - 1
    while left <= right:
        mid = (left + right) // 2
        if list[mid] == target:
            return mid
        elif list[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

const express = require('express');
const app = express();
app.use(express.json());
let users = [];
app.post('/users', (req, res) => {
    const { id, name } = req.body;
    users.push({ id, name });
    res.status(201).json({ message: 'User created', user: { id, name } });
});
app.listen(3000, () => console.log('Server running on port 3000'));

#include 
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++; std::swap(arr[i], arr[j]);
            }
        }
        std::swap(arr[i + 1], arr[high]);
        int pi = i + 1;
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
public class JWTUtil {
    private static final String SECRET = "agatha_secret_key";
    public static String generateToken(String user) {
        return Jwts.builder()
            .setSubject(user)
            .signWith(SignatureAlgorithm.HS256, SECRET)
            .compact();
    }
    public static void main(String[] args) {
        System.out.println(generateToken("admin"));
    }
}

pragma solidity ^0.8.0;
contract Registry {
    mapping(address => uint) public balances;
    event Transfer(address from, address to, uint amount);
    function transfer(address to, uint amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        emit Transfer(msg.sender, to, amount);
    }
}

fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
main = print (fib 10)

function multiply_matrices(A, B)
    m, n = size(A)
    n, p = size(B)
    C = zeros(m, p)
    for i in 1:m
        for j in 1:p
            for k in 1:n
                C[i,j] += A[i,k] * B[k,j]
            end
        end
    end
    return C
end

use std::thread;
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread: {}", i);
        }
    });
    handle.join().unwrap();
}

{
    "email": "[email protected]",
    "password": "secure_password_123"
}

{
    "message": "Generate a Python script to calculate factorial",
    "user_id": 1,
    "response_mode": "advanced_technical"
}

{
    "description": "Futuristic robot in a desert",
    "image_model": "Agatha_Epic_Realism_XL",
    "resolution": "1024x1024"
}

{
    "server_id": 1,
    "metrics": ["cpu", "memory", "disk"]
}