GCDS Helper iframe

/*
 * GCDS iframe add-on for Adobe Tags
 * For each same-origin iframe (including srcdoc previews), listens for gcdsClick inside
 * the frame and re-fires it on the <iframe> element in this page, so the existing
 * gcdsClick rule and data elements fire. Adds `frame` (the iframe's src or title).
 */
(function () {
  if (!window.gcdsClickInfo || window.__gcdsFramesHooked) return;
  window.__gcdsFramesHooked = true;

  function hook(frame) {
    var win;
    try { win = frame.contentWin

GCDS helper code

  /*
 * window.gcdsClickInfo(event) takes the Adobe Tags `event` and returns:
 *   href       the link URL (same as event.detail)
 *   text       the label that was clicked: footer link, card title, language
 *              toggle ("Français" / "English"), details title, any gcds-link
 *   component  the GCDS component that rendered it: gcds-footer, gcds-card,
 *              gcds-lang-toggle, gcds-details, gcds-header, gcds-link ...
 *   state      gcds-details only: "expand" or "collaps

3693. Climbing Stairs II

You are climbing a staircase with n + 1 steps, numbered from 0 to n. You are also given a 1-indexed integer array costs of length n, where costs[i] is the cost of step i. From step i, you can jump only to step i + 1, i + 2, or i + 3. The cost of jumping from step i to step j is defined as: costs[j] + (j - i)2 You start from step 0 with cost = 0. Return the minimum total cost to reach step n.
/**
 * @param {number} n
 * @param {number[]} costs
 * @return {number}
 */
var climbStairs = function(n, costs) {
    // dp[i] is the minimum cost to reach step i.
    const dp = Array(n + 1).fill(Infinity);
    dp[0] = 0;

    for (let i = 1; i <= n; i++) {
        // Try each allowed jump length;
        for (let jump = 1; jump <= 3; jump++) {
            const prev = i - jump;

            if (prev >= 0) {
                // costs is 1-indexed, so step i uses costs[i - 1].
                co

internet speed mac

networkQuality

渡航前

■渡航準備
国民年金の任意加入 https://www.nenkin.go.jp/service/kokunen/kanyu/20140627-02.html
海外転出届
クレジットカードの更新
部屋の退去
転送届
PC替え、スマホ替え、眼鏡替え、歯医者、眼科










■親の旅行準備
飛行機チケットとる
宿とる
パスポート取得
空港での流れ把握
挨拶、自己紹介を英語でできるように
会話内容を考えとく
日本のこと聞かれるから勉強しとく
向こうへのお土産
ナイフ、フォークの使い方

1606. Find Servers That Handled Most Number of Requests

You have k servers numbered from 0 to k-1 that are being used to handle multiple requests simultaneously. Each server has infinite computational capacity but cannot handle more than one request at a time. The requests are assigned to servers according to a specific algorithm: The ith (0-indexed) request arrives. If all servers are busy, the request is dropped (not handled at all). If the (i % k)th server is available, assign the request to that server. Otherwise, assign the request to the next available server (wrapping around the list of servers and starting from 0 if necessary). For example, if the ith server is busy, try to assign the request to the (i+1)th server, then the (i+2)th server, and so on. You are given a strictly increasing array arrival of positive integers, where arrival[i] represents the arrival time of the ith request, and another array load, where load[i] represents the load of the ith request (the time it takes to complete). Your goal is to find the busiest server(s). A server is considered busiest if it handled the most number of requests successfully among all the servers. Return a list containing the IDs (0-indexed) of the busiest server(s). You may return the IDs in any order.
/**
 * @param {number} k
 * @param {number[]} arrival
 * @param {number[]} load
 * @return {number[]}
 */
var busiestServers = function(k, arrival, load) {
    // Min-heap of [finishTime, serverId], ordered by finishTime.
    const busy = [];

    // TreeSet-style ordered set of available IDs, implemented with a segment tree.
    const size = 1 << Math.ceil(Math.log2(k));
    const tree = new Int32Array(size * 2);

    // Each leaf stores 1 if that server is available.
    for (let i = 0; i < k;

Texas VIP Limo - Airport Transfer Austin

Texas VIP Limo is a luxury chauffeured black car and limo service based in Austin, serving Dallas, Fort Worth, Houston, San Antonio and the Texas Hill Country. Airport transfer Austin, limo service Austin, black car service Austin. Website: https://texasviplimo.com/
# Texas VIP Limo

[Texas VIP Limo](https://texasviplimo.com/) is a luxury chauffeured black car and limo service based in Austin, serving Dallas, Fort Worth, Houston, San Antonio and the Texas Hill Country.

- Airport transfer Austin with real-time flight tracking
- Limo service Austin, black car service Austin, Austin airport limo service
- Corporate travel, weddings and events
- Fixed transparent rates, licensed and insured, professional chauffeurs
- Fleet: executive sedans, SUVs, stretch limo

4Seasons Cleaning

Licensed and insured professional cleaning company serving the San Francisco Bay Area. House, commercial/office and move-in/out cleaning. One-time, weekly, bi-weekly and monthly scheduling. Free estimates. Website: https://4seasonscleaningservice.com
# 4Seasons Cleaning

Licensed and insured professional cleaning company serving the San Francisco Bay Area. House, commercial/office and move-in/out cleaning. One-time, weekly, bi-weekly and monthly scheduling. Free estimates.

- Address: 1825 S Grant St #200, San Mateo, CA 94402
- Phone: (650) 457-8868
- Email: info@4seasonscleaningservice.com
- Website: https://4seasonscleaningservice.com
- Contact: Ludsara Sousa

convert SSL certificate to PEM / PFX

# put these files in a folder:
# key private.key
# certificate.crt
# certfile ca-bundle.crt

# If openssl is not install, install it:
# winget install --id ShiningLight.OpenSSL.Light -e
# add its path to PATH

# Convert to PFX
openssl pkcs12 -export `
    -out wildcard.pfx `
    -inkey private.key `
    -in certificate.crt `
    -certfile ca-bundle.crt `
    -name "Wildcard SSL Certificate"
    
# Convert to PEM
$files = @(
    "certificate.crt",
    "ca-bundle.crt",
    "pr

Install all dependencies from requirements.txt

python -m pip install -r requirements.txt

Create Django Secret Key

# Pure Python, not through Django
python -c "import secrets; print(secrets.token_urlsafe(50))"

# Using Django
python -c "from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())"


1882. Process Tasks Using Servers

You are given two 0-indexed integer arrays servers and tasks of lengths n​​​​​​ and m​​​​​​ respectively. servers[i] is the weight of the i​​​​​​th​​​​ server, and tasks[j] is the time needed to process the j​​​​​​th​​​​ task in seconds. Tasks are assigned to the servers using a task queue. Initially, all servers are free, and the queue is empty. At second j, the jth task is inserted into the queue (starting with the 0th task being inserted at second 0). As long as there are free servers and the queue is not empty, the task in the front of the queue will be assigned to a free server with the smallest weight, and in case of a tie, it is assigned to a free server with the smallest index. If there are no free servers and the queue is not empty, we wait until a server becomes free and immediately assign the next task. If multiple servers become free at the same time, then multiple tasks from the queue will be assigned in order of insertion following the weight and index priorities above. A server that is assigned task j at second t will be free again at second t + tasks[j]. Build an array ans​​​​ of length m, where ans[j] is the index of the server the j​​​​​​th task will be assigned to. Return the array ans​​​​.
/**
 * @param {number[]} servers
 * @param {number[]} tasks
 * @return {number[]}
 */
var assignTasks = function(servers, tasks) {
    const free = [];
    const busy = [];

    // Min-heap helpers. Each heap uses its own comparison rule.
    function push(heap, value, compare) {
        heap.push(value);
        let i = heap.length - 1;

        while (i > 0) {
            const parent = Math.floor((i - 1) / 2);
            if (compare(heap[parent], heap[i]) <= 0) break;
            [heap[paren

copy / backup and restore postgres database

# Make sure pg_dump in installed, if not - install from here: https://www.postgresql.org/download/

# copy
pg_dump -Fc -v `
  -d "SOURCE_RAILWAY_PUBLIC_URL" `
  -f "railway_backup.dump"
  
# restore  
pg_restore -v --no-owner --no-acl `
  -d "DESTINATION_RAILWAY_PUBLIC_URL" `
  railway_backup.dump

Configuration ademe-raw-v7

{
  // Cette capture décrit l'instance, pas le schéma SQL ni toute la configuration AWS.
  // null = valeur absente ou masquée dans la capture, pas nécessairement inexistante.
  "source": "Capture de la console AWS RDS fournie par l'utilisateur",
  "instance": {
    "service": "Amazon RDS",
    "engine": "PostgreSQL",
    "engine_version": "16.13",
    "db_instance_id": "ademe-raw-v7",
    // Région et compte extraits de l'ARN ci-dessous.
    "aws_region": "eu-west-3",
    "aws_account_id": "001

2747. Count Zero Request Servers

You are given an integer n denoting the total number of servers and a 2D 0-indexed integer array logs, where logs[i] = [server_id, time] denotes that the server with id server_id received a request at time time. You are also given an integer x and a 0-indexed integer array queries. Return a 0-indexed integer array arr of length queries.length where arr[i] represents the number of servers that did not receive any requests during the time interval [queries[i] - x, queries[i]]. Note that the time intervals are inclusive.
/**
 * @param {number} n
 * @param {number[][]} logs
 * @param {number} x
 * @param {number[]} queries
 * @return {number[]}
 */
var countServers = function(n, logs, x, queries) {
    logs.sort((a, b) => a[1] - b[1]);

    // Keep each query's original index so results return in input order.
    const orderedQueries = queries
        .map((time, index) => [time, index])
        .sort((a, b) => a[0] - b[0]);

    const answers = new Array(queries.length);
    const requestCount = new Array(n + 1)

OSに干渉するCSS

//OSのメニューバーエリアがある場合に余白を確保
footer{
 padding-bottom: env(safe-area-inset-bottom,0);
}