mayton2019

aria2, cli-качалка для разных форматов.
https://aria2.github.io/manual/ru/html/aria2c.html...

aria2c --show-files "твой торрент.torrent" - показать файлы и индексы

aria2c --select-file 41-49 "твой торрент.torrent" загрузить файлы с индексами такими-то

Хоть и вопрос несколько сумбурный и не совсем понятно, что автор хочет на самом деле...
Но краткий ответ: да, возможно, но есть нюансы...

Самый простой вариант - запускать node как отдельный процесс. Можно просто запускать на каждый чих, а можно заморочиться и организовать общение между приложением на Rust и приложением на Node.js

Вариант поинтереснее - Node.js можно собрать как библиотеку (есть даже готовые бинарные сборки такого), линкуем с приложением на Rust. Всё живёт в одном процессе, но node будет запускать свои потоки.

Есть и обратный последнему вариант. Можно из Rust кода собрать бинарный аддон к Node.js
Правда тут уже JS код будет запускать код на Rust.
https://napi.rs
https://neon-rs.dev

Можно пойти дальше. Если задача просто исполнять JS код из приложения на Rust, то можно слинковаться с одним из JS движков. Приколюх предоставляемых платформой Node.js здесь не будет (вроде fs или http), хотя никто не мешает реализовать это самостоятельно.
https://crates.io/crates/v8
https://crates.io/crates/quickjs_runtime

Формула включения-исключения. Берете все графы, где хотя бы одна вершина соединена со всеми (их n*2^(n-2)*(n-1)), вычитаете все графы, где хотя бы две вершины соеденины со всеми (2 раза, ведь они 2 раза подсчитались), прибавляете графы, где хотя бы 3 вершины соеденины со всеми (3 раза)... И т.д.

Графов, где хотя бы k вершин имеют степень n-1 - C(n, k)*2^{(n-k-1)(n-k)/2}: тут можно выбрать k вершин и для каждого ребра из оставшихся n-k вершин есть 2 варианта - оно или есть, или нет.

Это будет за O(n log n) решение, если пердподсчитать все факториалы и обратные к им по модулю в задаче. Ну, или O(n^2), если считать сочетания через треугольник паскаля.

Ражеванное объяснение:

Сложно подсчитать количество графов где ровно 1 вершина такая полная. Но легко подсчитать те, где k или более таких. Мы их такие зафиксируем и нарисуем от них все ребра. А все оставшиеся ребра в графе могут быть любыми. Во-первых, можно выбрать эти k вершин - поэтому у нас есть множитель C[n,k]. Оставшиеся, незафиксированные ребра идут между любыми двумя оставшимся n-k вершин. Их (n-k)(n-k-1)/2. И каждое может быть или проведено или нет.

Поэтому всего таких графов, с не менее k вершин: F(k)=C[n,k]*2^{(n-k)(n-k-1)/2}.

Теперь, как подсчитать графы ровно с 1 вершиной? Можно взять F(1). Но мы насчитали много лишнего, Графы с 2мя такими вершинами мы в F(1) подсчитали 2 раза. Поэтому вычтем 2F(2). Теперь графы ровно с 3 вершинами мы подсчитали 3 раза в F(1) и 3 раза в каждом F(2). Поэтому пока мы их насчитали 3-2*3 = -3 раза. Поэтому прибавим 3F(3). И далее, получится, что графы ровно с 4-мя вершинами мы подсчитали 4 раза (4-2*6+3*4). И т.д.

fn main() -> MainResultWrapper {
    MainResultWrapper(main_inner())
}

#[inline(always)]
fn main_inner() -> Result<(), GlobalError> {
    let config = read_config_from_file()?;
    Ok(())
}

Разница по горизонтали всегда +2. Значит число из строки 2 будет входить с коэффициентом 2.
По вертикали разница на -1. Значит число из столбца B будет с коэффициентом -1.

Итак, формула -1*$B3+2*C$2 - 1 . -1 в конце подбираем так, чтобы в самой первой ячейке оказался 0.

Большой и сложный бинарник вы так не встроите. Максимум, отдельные функции.

Для винды можно ваш второй файл сделать в виде dll и выпоннять код во время ее загрузки. Чуть подправить исполняемый файл или вообще просто положить dll-ку рядом с exe-шником - и библиотека загрузится.

Или можно найти пустое место в целевом файле в секции кода. Воткнуть туда вашу функцию и поменять точку входа на нее (а сама функция потом прыгает на изначальную точку входа). Если места нет, то придется увеличивать секцию кода.

В этом случае, надо изучить устройство PE файла, понимать немного ассемблера.

Cell<T> has the same memory layout and caveats as UnsafeCell<T>. In particular, this means that Cell<T>has the same in-memory representation as its inner type T.

У остальных нет никаких обязательств о memory representation, но они тоже ничего в куче не выделяют.

Ну и всегда можно посмотреть на исходники)
https://doc.rust-lang.org/src/core/cell.rs.html#293
https://doc.rust-lang.org/src/core/cell.rs.html#2034
https://doc.rust-lang.org/src/core/cell.rs.html#700
https://doc.rust-lang.org/src/core/cell/once.rs.html#33

Низкий порог вхождения для C++ и Vulkan означает продвинутый уровень владения инструментом C++, экспертные навыки обработки графики, работы с шейдерами и управления памятью GPU (да, там все иначе). Для входа в работу с Vulkan нужно быть, как минимум, Middle Graphics Engineer и уже уметь уверенно работать с DirectX11 или OpenGL4.5. Без этих знаний вулкан будет очень сложно понять, а правильно работать с ним получится только через десятки и сотни полностью неудачных итераций написать одно и то же.

Vulkan является очень низкоуровневым GAPI и требует от пользователя изначально серьезной подготовки. У этого GAPI много точек привязки к системной памяти, содержимое которой трактуется как на GPU, так и на CPU. Поэтому работать с памятью в C++ правильно нужно уметь с самого начала. Поэтому, еще до начала работы с вулканом от пользователя требуются экспертные знания языка. В противном случае вместо обучения работе с довольно сложным GAPI получится блуждание по полю граблей, где ничего не понятно.

При этом, курсов, статей и книг для обучения вулкану очень много и их очень легко найти.
Есть очень хороший цикл статей для самостоятельного обучения, есть даже перевод на наш язык.
Есть множество книг, по которым люди учатся работать с вулканом. Learning Vulkan считается самой лучшей.
Поисковиком легко ищутся разные мелкие примеры работа с вулканом.
Есть даже онлайн курсы для обучения под наблюдением инструктора.

И тем не менее, вулкан легко не дастся. Для его понимания нужна база, нужно знать устройство GPU, принципы коммуникации с ним, принципы его работы и всю теорию обработки графики. Нужно уже уметь быстро писать много стабильного и сложного кода на C++, нужно уметь безошибочно писать на GLSL или SPIR-V. Нужно уметь пользоваться графическими отладчиками, профилировщиками, разбираться в диагностике проблем при работе с графикой.
Все это приобрести можно в процессе практики с DirectX11 и OpenGL4.5.