qt.qpa.plugin: Could not find the Qt platform plugin "cocoa" in ""
This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.

[Paths]
Plugins = Resources/plugins

static_cast<uint32_t>(1) << 31;  // 0b1000...0000 (0 が 31 個) 期待通り
static_cast<uint32_t>(1) << 32;  // 0 にならない。不定
static_cast<uint32_t>(1) << 33;  // 0 にならない。不定
static_cast<uint64_t>(1) << 63;  // 0b1000...0000 (0 が 63個) 期待通り
static_cast<uint64_t>(1) << 64;  // 0 にならない。不定
static_cast<uint64_t>(1) << 65;  // 0 にならない。不定

// index よりも小さい桁にあるビット数を数える意図の関数だが、
// index = 0 の時の返り値が不定になるバグがある
int PopCountRhs(uint64_t bitmap, int index) {
  return popcount(bitmap << (64 - index));  // INVALID CODE
}

import asyncio
import sys
from asyncio.subprocess import PIPE

async def run_shell():
  process = await asyncio.create_subprocess_exec(
    '/bin/sh', stdin=PIPE, stdout=PIPE)

  while process.returncode is None:
    command = input('> ')
    process.stdin.write(command.encode('utf-8') + b'\n')

    while True:
      try:
        line = await asyncio.wait_for(process.stdout.readline(), timeout=0.1)
      except asyncio.TimeoutError:
        break

      if not line:
        break

      print(line.decode('utf-8'), end='')

  return await process.wait()


if sys.platform == 'win32':
  loop = asyncio.ProactorEventLoop()
  asyncio.set_event_loop(loop)
else:
  loop = asyncio.get_event_loop()


returncode = loop.run_until_complete(run_shell())
loop.close()

import asyncio
import concurrent.futures
import subprocess
import sys
import threading
from asyncio.subprocess import PIPE


is_terminate = threading.Event()


async def check_interuption(loop):
  reader = asyncio.StreamReader()
  protocol = asyncio.StreamReaderProtocol(reader)
  await loop.connect_read_pipe(lambda: protocol, sys.stdin)

  line = await reader.readline()
  print('read:' + line.decode('utf-8'))
  is_terminate.set()


async def run_command(args):
  process = await asyncio.create_subprocess_exec(*args, stdout=PIPE)
  output = []

  while not is_terminate.is_set():
    try:
      line = await asyncio.wait_for(process.stdout.readline(), timeout=0.1)
    except asyncio.TimeoutError:
      continue

    line = line.decode('utf-8')
    output.append(line)
    print(line, end='')

  return ''.join(output)


def get_event_loop():
  if sys.platform == 'win32':
    loop = asyncio.ProactorEventLoop()
    asyncio.set_event_loop(loop)
  else:
    loop = asyncio.get_event_loop()
  return loop


loop = get_event_loop()

args = ['/usr/local/bin/adb', 'shell', 'getevent', '/dev/input/event1']
futures = asyncio.gather(run_command(args), check_interuption(loop))
output = loop.run_until_complete(futures)[0]

print(output)
loop.close()

adb exec-out screencap -p > image.png

  QWidget window;
  window.setWindowFlags(Qt::ToolTip |
                        Qt::FramelessWindowHint |
                        Qt::WindowStaysOnTopHint);

git clone -c core.autocrlf=false https://github.com/<REPOSITORY>

std::string_view sv1(char_pointer);
std::string_view sv2(char_pointer + 5);

// BAD
// int offset = sv2.begin() - sv1.begin();

// GOOD
int offset = sv2.data() - sv1.data();

cd <submodule_dir>
git fetch --tags
git checkout tags/<tag_name>
git submodule update

cd <main_dir>
git add <submodule_dir>
git commit

#include <QtWidgets/QtWidgets>

class Receiver : public QObject {
  Q_OBJECT

 public:
  void HandleValue(int i);
};

class Sender : public QObject {
  Q_OBJECT

 public:
  Sender(Receiver *receiver);

  void RunLoop(int times);
  void SetValue(int i);

 signals:
  void EmitRunLoop(int times);
  void EmitValue(int i);
};

#include "my_qt_thread.h"

#include <unistd.h>
#include <iostream>

Sender::Sender(Receiver *receiver) {
  connect(this, &Sender::EmitValue, receiver, &Receiver::HandleValue);
  connect(this, &Sender::EmitRunLoop, this, &Sender::RunLoop);
}

void Sender::RunLoop(int times) {
  for (int i = 0; i < times; ++i) {
    sleep(1);
    SetValue(i);
  }
}

void Sender::SetValue(int i) {
  std::cout << "Sender::SetValue: " << i << std::endl;
  emit EmitValue(i);
}

void Receiver::HandleValue(int i) {
  std::cout << "Receiver::HandleValue: " << i << std::endl;
}

int main(int argc, char **argv) {
  QApplication app(argc, argv);

  Receiver receiver;

  Sender sender1(&receiver);
  QThread thread1;
  sender1.moveToThread(&thread1);
  thread1.start();
  emit sender1.EmitRunLoop(10);

  Sender sender2(&receiver);
  QThread thread2;
  sender2.moveToThread(&thread2);
  thread2.start();
  emit sender2.EmitRunLoop(3);

  const int result = app.exec();
  thread1.wait();
  thread2.wait();
  return result;
}

split -n l/10 -d --additional-suffix=.txt data.txt data

git diff-tree --name-only --no-commit-id -r abcd123

% cat a.txt
a
b
c
% cat b.txt
0
1
2
% paste a.txt b.txt
a	0
b	1
c	2

pkgutil --expand-full Application.pkg /tmp/extracted

cd <base_dir>
zip -ry archive.zip <target>

{
  "title": "Right-Option/PrintScreen to copy/paste w/o format (Shift + Command + v)",
  "rules": [
    {
      "description": "Right-Option/PrintScreen to copy/paste w/o format (Shift + Command + v).",
      "manipulators": [
        {
          "type": "basic",
          "from": {
            "key_code": "right_option"
          },
          "to": [
            {
              "key_code": "c",
              "modifiers": [
                "left_command"
              ]
            }
          ]
        },
        {
          "type": "basic",
          "from": {
            "key_code": "print_screen"
          },
          "to": [
            {
              "key_code": "v",
              "modifiers": [
                "left_command",
                "left_shift"
              ]
            }
          ]
        }
       ]
    }
  ]
}

% hdiutil imageinfo myimage.dmg

=INDEX({100, 200, 300}, 1)

git update-index --assume-unchanged src/config.txt

git update-index --no-assume-unchanged src/config.txt

function toHiragana(args) {
  if (Array.isArray(args)) {
    let output = [];
    for (let arg of args) {
      output.push(toHiragana(arg));
    }
    return output;
  }

  if (typeof args != "string") {
    return "";
  }

  let codes = [];
  for (let chr of args) {
    const offset = ('ァ' <= chr && chr <= 'ヶ') ? -0x0060 : 0;
    codes.push(chr.charCodeAt() + offset);
  }
  return String.fromCharCode(...codes);
}

comm -12 sorted_lines1.txt sorted_lines2.txt > common_lines.txt

sed -e 's/^/prefix/' file.txt > prefixed_file.txt

[
  {
    "key": "tab",
    "command": "type",
    "args": {"text": "\t"},
    "when": "editorTextFocus && editorLangId == plaintext"
  }
]

% git tag -a {tag} {commit-id}
% git push -u origin master {tag}

% git tag -a 2.26.4660.102 063c41f1d7c1a877f44c1f8caad6be1897350336
% git push -u origin master 2.26.4660.102

convert -background none -density 1024 -resize 16x16 -extent 16x16 -gravity Center icon.svg icon_16.png
convert -background none -density 1024 -resize 24x24 -extent 24x24 -gravity Center icon.svg icon_24.png
convert -background none -density 1024 -resize 32x32 -extent 32x32 -gravity Center icon.svg icon_32.png
icotool -c icon_16.png icon_24.png icon_32.png > icon.ico

for n in icon1 icon2 icon3; do
  PNGS=()
  for s in 16 20 24 32 48 64 128 256; do
    convert -background none -density 1024 -resize ${s}x${s} -extent ${s}x${s} -gravity Center ${n}.svg ${n}_${s}.png
    PNGS+=${n}_${s}.png
  done
  icotool -c $PNGS[@] > ${n}.ico
done

sudo powermetrics --samplers smc -n 1

pkgutil --pkgs

pkgutil --files [package_name]

sudo pkgutil --forget  [package_name]

osascript \
    -e 'tell application "Terminal"' \
    -e 'set position of front window to {1, 1}' \
    -e 'end tell'

sudo installer -pkg MyApp.pkg -target / 

adb pull /data/data/com.example.package/databases/data.db .

adb shell "su -c cat /data/data/com.example.package/databases/data.db" > data.db

adb shell "run-as com.example.package cat /data/data/com.example.package/databases/data.db" > data.db

adb backup -noapk com.example.package

adb shell pm list packages 

curl "https://raw.githubusercontent.com/newren/git-filter-repo/main/git-filter-repo" > ~/git-filter-repo

git clone https://github.com/USER/SOURCE_REPO.git
cd SOURCE_REPO
python3 ~/git-filter-repo --path PROJECT
python3 ~/git-filter-repo --subdirectory-filter PROJECT
git remote add origin https://github.com/USER/NEW_REPO.git
git push -u origin main