text:
---
title: "Subscribing to messages"
description: ""
weight: 1
---

The Application Server publishes on the following topics:

- `v3/{application id}/devices/{device id}/join`
- `v3/{application id}/devices/{device id}/up`
- `v3/{application id}/devices/{device id}/down/queued`
- `v3/{application id}/devices/{device id}/down/sent`
- `v3/{application id}/devices/{device id}/down/ack`
- `v3/{application id}/devices/{device id}/down/nack`
- `v3/{application id}/devices/{device id}/down/failed`

While you could subscribe to separate topics, for the tutorial subscribe to `#` to subscribe to all messages.

With your MQTT client subscribed, when a device joins the network, a `join` message gets published. For example, for a device ID `dev1`, the message will be published on the topic `v3/app1/devices/dev1/join` with the following contents:

```json
{
  "end_device_ids": {
    "device_id": "dev1",
    "application_ids": {
      "application_id": "app1"
    },
    "dev_eui": "4200000000000000",
    "join_eui": "4200000000000000",
    "dev_addr": "01DA1F15"
  },
  "correlation_ids": [
    "gs:conn:01D2CSNX7FJVKQPCVG612QF1TX",
    "gs:uplink:01D2CT834K2YD17ZWZ6357HC0Z",
    "ns:uplink:01D2CT834KNYD7BT2NHK5R1WVA",
    "rpc:/ttn.lorawan.v3.GsNs/HandleUplink:01D2CT834KJ4AVSD1SJ637NAV6",
    "as:up:01D2CT83AXQFQYQ35SR74CTWKH"
  ],
  "join_accept": {
    "session_key_id": "AWiZpAyXrAfEkUNkBljRoA=="
  }
}
```

You can use the correlation IDs to follow messages as they pass through the stack.

When the device sends an uplink message, a message will be published to the topic `v3/{application id}/devices/{device id}/up`. This message looks like this:

```json
{
  "end_device_ids": {
    "device_id": "dev1",
    "application_ids": {
      "application_id": "app1"
    },
    "dev_eui": "4200000000000000",
    "join_eui": "4200000000000000",
    "dev_addr": "01DA1F15"
  },
  "correlation_ids": [
    "gs:conn:01D2CSNX7FJVKQPCVG612QF1TX",
    "gs:uplink:01D2CV8HF62ME0D7MZWE38HHH8",
    "ns:uplink:01D2CV8HF6FYJHKZ45YY1DB3MR",
    "rpc:/ttn.lorawan.v3.GsNs/HandleUplink:01D2CV8HF6XR7ZFVK768PDG3J4",
    "as:up:01D2CV8HNGJ57G25BW0FCZNY07"
  ],
  "uplink_message": {
    "session_key_id": "AWiZpAyXrAfEkUNkBljRoA==",
    "f_port": 15,
    "frm_payload": "VGVtcGVyYXR1cmUgPSAwLjA=",
    "rx_metadata": [{
      "gateway_ids": {
        "gateway_id": "eui-0242020000247803",
        "eui": "0242020000247803"
      },
      "time": "2019-01-29T13:02:34.981Z",
      "timestamp":<PHONE_NUMBER>,
      "rssi": -35,
      "snr": 5,
      "uplink_token": "CiIKIAoUZXVpLTAyNDIwMjAwMDAyNDc4MDMSCAJCAgAAJHgDEMj49+ME"
    }],
    "settings": {
      "data_rate": {
        "lora": {
          "bandwidth": 125000,
          "spreading_factor": 7
        }
      },
      "data_rate_index": 5,
      "coding_rate": "4/6",
      "frequency": "868500000",
      "gateway_channel_index": 2,
      "device_channel_index": 2
    }
  }
}
```


text:
# Project Name
Giovanni's Pizzeria.

## Project Description
- A pizza web application done in HTML, CSS and JS.

## Author
- [John Karima](https://github.com/JohnKarima)

## Setup Instructions
- Clone the repository
```
$ git clone giovanni-pizza
```
- Move into directory
```
$ cd giovanni-pizza
```
- Open project on code editor
```
$ code .
```
- Run the project on Live Server

## Link to Live Project
- https://johnkarima.github.io/giovanni-pizza/

## Technologies Used
- HTML, CSS, JavaScript, Bootstrap & JQuery

## Contact Information
<EMAIL_ADDRESS>
## License Copyright
- 2020, John Karima.

https://opensource.org/licenses/MIT

license: MIT

repository: JohnKarima/giovanni-pizza

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: JohnKarima/giovanni-pizza


text:
---
layout: default
---

# 1995-09-21 - Re: first virtual "security" (!!) (was Re: Security Flaw Is Discovered In Software Used in Shopping)

## Header Data

From: Laurent Demailly<EMAIL_ADDRESS>To: Nathaniel Borenstein<EMAIL_ADDRESS>Message Hash: dd9b84871240924f65323eea361365c3cf9e6bb47e2782efb66c2a0e21567ec1

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-09-21 03:48:42 UTC

Raw Date: Wed, 20 Sep 95 20:48:42 PDT

## Raw message

```
{% raw  %}From: Laurent Demailly<EMAIL_ADDRESS>Date: Wed, 20 Sep 95 20:48:42 PDT
To: Nathaniel Borenstein<EMAIL_ADDRESS>Subject: Re: first virtual "security" (!!) (was Re: Security Flaw Is Discovered In Software Used in Shopping)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

You have excellent points in your detailed answer, thank you, but

If FV was as used as SSL could be, what prevents, to use your terms,
someone to get MILLIONS of FV's identifiers and use each one only
once, etc ... (imo your figures about SSL and crypto softs risks are
over evaluated, so I over evaluate the 'risks' of yours using same
assumptions)

There can't be more security by transferring data on the clear
compared to an encrypted one... except maybe that people using
encryption can often feel overconfident. So, as someone pointed out,
it is not that much a problem about CC# which are available easily
anyway, but in fact, using encrypted communications is the only way to
ensure (some) *privacy*, in addition to being a security improvement. A
problem is to avoid to fail on "customer expectation", especially when
you've created it. So probably there was too much focus and
advertising on security issues on the internet, by the very same
companies that prove later to fail, giving wrong expectation. Privacy
remains a goal anyway, and financial insecurity never was a problem as
long as it remains under a small %.

So I'd prefer to use crapy netscape 1.1 40 bits export SSL than your
system... Though what I'd really use is PGP :-)

Anyway, if you have happy customers, good for you... I'd suggest that
you'd use "Security through Clarity" as motto ;-)

dl
--
Laurent Demailly * http://hplyot.obspm.fr/~dl/ * Linux|PGP|Gnu|Tcl|...  Freedom
Prime#1: cent cinq mille cent cinq milliards cent cinq mille cent soixante sept

fissionable SEAL Team 6 Kaser Sose nuclear Clinton domestic
disruption DST

{% endraw %}
```

## Thread

+ Return to [September 1995](/archive/1995/09)

+ Return to<EMAIL_ADDRESS>(Ian Goldberg)](/authors/iagoldbe_at_csclub_uwaterloo_ca_ian_goldberg_)"
+ Return to "[Laurent Demailly <dl@hplyot.obspm.fr>](/authors/laurent_demailly_dl_at_hplyot_obspm_fr_)"
+ Return to "[Nathaniel Borenstein <nsb@nsb.fv.com>](/authors/nathaniel_borenstein_nsb_at_nsb_fv_com_)"
+ Return to<EMAIL_ADDRESS>(Robert Hettinga)](/authors/rah_at_shipwright_com_robert_hettinga_)"

+ 1995-09-20 (Wed, 20 Sep 95 08:18:15 PDT) - [Re: Security Flaw Is Discovered In Software Used in Shopping](/archive/1995/09/940a69feaa3b80de5eb713d87aa8e5f97a0eb5afbbf2fc1ead34459ea9b89274) -<EMAIL_ADDRESS>(Robert Hettinga)_
  + 1995-09-20 (Wed, 20 Sep 95 14:28:37 PDT) - [first virtual "security" (!!) (was Re: Security Flaw Is Discovered In Software Used in Shopping)](/archive/1995/09/88718c9d42c5024625a49dce19d90c31aea69106bf8ce9ce1417b885d2a0bbd5) - _Laurent Demailly<EMAIL_ADDRESS>  + 1995-09-21 (Wed, 20 Sep 95 20:46:59 PDT) - [Re: first virtual "security" (!!) (was Re: Security Flaw Is Discovered In Software Used in Shopping)](/archive/1995/09/0a969e8c34070c8908b5b7f34fcf873e95359c1c572effe663eb1664f415c406) - _Nathaniel Borenstein<EMAIL_ADDRESS>  + 1995-09-21 (Wed, 20 Sep 95 20:48:42 PDT) - Re: first virtual "security" (!!) (was Re: Security Flaw Is Discovered In Software Used in Shopping) - _Laurent Demailly<EMAIL_ADDRESS>  + 1995-09-21 (Wed, 20 Sep 95 23:03:56 PDT) - [[NOISE] "hacker" was: first virtual "security"](/archive/1995/09/bca1af80e8089944ca39c9e2b446be8bbc6317649e3086f98006b6ff9c140635) -<EMAIL_ADDRESS>(Ian Goldberg)_

gha_license_id: MIT


text:
## Overview

Maybe I'm alone here, but I don't like developing apps directly on my
laptop.

Not only do you need to install a bunch of libraries and databases only
needed to develop that one app -- and then never clean it out -- but you're
probably running different library versions, and a different OS, than your
server environment.

So when you go to deploy, there's no end to the fun you can have. Of course,
CI can protect you from trashing your production machines, but you still
need to troubleshoot your CI server when the build breaks.

The solution to all of this is to develop either in a virtual machine, or
on a remote server, but there are drawbacks there, too.

Enter Workspace: Smooth integration between your laptop and your remote and/or
virtual development boxes.

Workspace requires only  `ssh`, `sshfs`, `bash`, and `git` to run, and has
been tested on OS X and Ubuntu Linux, with both `rbenv` and `rvm` (although
shims don't work with `rvm` -- see below)

Repositories live on the remotes, and are mounted locally via `sshfs`.

Workspace provides shims in your path to seamlessly run commands on your
development machines when you are in the repository, and this works
seamlessly over any number of hosts.

You can also namespace your work for clients, and move projects on or
offline as you need to -- no need to keep everything mounted all the time.

## Installation

1. Put the `ws` script into your personal bin directory.

2. Run `echo 'eval "$(ws init)"' >> ~/.bash_profile`

3. `source .bash_profile` or restart your login shell.

## Using The Damn Thing

My next genius idea is microblogging for LISP programmers. I've got a Rails
app on Github, and I want to start working on it in virtual machine called
`jayne`.

I start by adding the project to my Workspace:

    ws add git@github.com:matadon/thwitter.git jayne

The repository is checked out into `~/ws/thwitter` on jayne, which is
mounted via `sshfs` on my local machine

Let's make sure everything is set up on that machine with Bundler:

    cd ~/ws/project
    ws exec bundle

Now, that's all fine and well, but I'm going to be running `rails`,
`bundle`, and probably `rake` all the time. It would be nice if when I'm in
the project, those commands get run on the remote host, without having to
type a whole eight extra characters. If only there was a way...

    ws shim rails rake bundle

Now, whenever I run a shimmed command anywhere under `~/ws/thwitter`, that
command is run on the remote. Outside of the project directory, commands are
run locally. Which means I can do this:

    cd ~/ws/thwitter
    rails server

And then get to work.

## Note to `rvm` users.

Workspace works fine with `rvm`, with one exception: shims.

Fortunately, you can still use the rest of Workspace, including `ws exec`,
to run commands on your remote machines. I've got a handy shell alias set up
for that to cut down on the typing:

    echo 'alias r="ws exec"' >> ~/.bash_profile
    source ~/.bash_profile

Which means that this now works just fine:

    cd ~/ws/thwitter
    r rails server

Why, you ask? `rvm` hooks into the shell very deeply, in order to ensure
that it comes before anything else in your `$PATH`, and it checks -- early
and often -- to ensure that you have no other gods before `rvm`.

Since `ws shim` *also* wants to be before stuff in your `$PATH`, there's a
pretty clear conflict of interest. But since Workspace doesn't hook into the
shell at all, `rvm` shoves it out of the way in short order.

I don't have a clear path (ha-ha) to resolve this at present, so if you're
using `rvm`, shims are out for you.

But, if you're an `rvm` expert and can tell me how I can make this work --
or better yet, want to submit a pull request -- then I'd be very happy to
update Workspace to offer full support for `rvm`.

## Extra Free Stuff!

If you have a machine that you regularly develop on, you can set it as the
default host for new projects:

    ws set host [hostname]

Workspace also provides a one-level namespace so you can, for example,
separate out client projects. This will put my project in
`~/ws/lispers/thwitter`:

    ws add git@github.com:matadon/thwitter.git jayne lispers

If I want to unmount that project:

    ws down lispers/thwitter

And I can bring all the projects for that client back up with:

    ws up lispers/%

Or you can just shell in as well:

    cd ~/ws/project
    ws shell

See `ws help` for more details.

## Speeding Things Up

Add the following to your `~/.ssh/config`:

    # Re-use connections.
    ControlMaster auto
    ControlPath ~/.ssh/tmp/%r@%h:%p
    ControlPersist yes

    # Use a faster cipher by default.
    Ciphers blowfish-cbc,aes128-cbc,3des-cbc,cast128-cbc,arcfour,aes192-cbc,aes256-cbc

    # Maximum data-squeeziness.
    Compression yes
    CompressionLevel 6

repository: matadon/workspace

gha_language: Shell

repo_name: matadon/workspace


text:
---
layout: default
---

# 1993-10-19 - Re: backing?

## Header Data

From<EMAIL_ADDRESS>(Doug Merritt)

To<EMAIL_ADDRESS>Message Hash: 4a7f476ee19dcf368dcd740f9398cedb87598b0569cb10ef40bb768274628bf8

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-10-19 14:57:29 UTC

Raw Date: Tue, 19 Oct 93 07:57:29 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Doug Merritt)
Date: Tue, 19 Oct 93 07:57:29 PDT
To<EMAIL_ADDRESS>Subject: Re: backing?
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<EMAIL_ADDRESS>said:
>Average inflation between the elimination of gold drawing rights and
>the banning of gold ownership by private citizens and 1970 were higher
>than in the immediate period before that. [...]
>Seems to be a pattern to me, buddy boy. [...]
>we should follow the historical models. Gold cannot be printed, is
>cheap to store, and is widely recognized as having value.

Just in case I was unclear: my point was that it makes sense to have
digital currency that is backed by gold, not just the other forms which
are not thereby backed.

I expect that lots of folks will support their own idiosyncratic forms
of digital currency in the future, somewhat similarly to the way that
banks used to issue their own paper currency, and that therefore there
will not be just a single kind of digital currency.
	Doug

{% endraw %}
```

## Thread

+ Return to [October 1993](/archive/1993/10)

+ Return to<EMAIL_ADDRESS>(Doug Merritt)](/authors/doug_at_netcom_com_doug_merritt_)"

+ _Unknown thread root_
  + 1993-10-19 (Tue, 19 Oct 93 07:57:29 PDT) - Re: backing? -<EMAIL_ADDRESS>(Doug Merritt)_


text:
# azure-iot-common.RetryPolicy Requirements

## Overview

The `RetryPolicy` interface and classes implement the necessary logic to compute retry intervals using different algorithms and parameters when an operation (such as sending a D2C message) fails.

## Example

```js
var policy = new ExponentialBackoffWithJitter(new DefaultErrorFilter());
var firstTimeout = policy.nextRetryTimeout(1, false);
var secondTimeout = policy.nextRetryTimeout(2, false);

// the second parameter indicates whether the algorithm should use normal parameters (false)
// or parameters adapted to situations where the Azure IoT hub is throttling
var timeoutWhenThrottled = policy.nextRetryTimeout(1, true);
// timeoutWhenThrottled will be longer than firstTimeout.

var errorFilter: {
  TimeoutError: false
};

var policy = new ExponentialBackoffWithJitter(errorFilter);
var shouldBeFalse = policy.shouldRetry(new errors.TimeoutError());
```

## Public API:

### RetryPolicy interface

**SRS_NODE_COMMON_RETRY_POLICY_16_001: [** Any implementation of the `RetryPolicy` interface shall have a `shouldRetry` method used to evaluate if an error is "retryable" or not. **]**

**SRS_NODE_COMMON_RETRY_POLICY_16_002: [** Any implementation of the `RetryPolicy` interface shall have a `getNextTimeout` method used to return the timeout value corresponding to the current retry count. **]**

### NoRetry

#### shouldRetry(error)

**SRS_NODE_COMMON_RETRY_POLICY_16_03: [** The `shouldRetry` method shall always return `false`. **]**

#### getNextTimeout(currentRetryCount, isThrottled)

**SRS_NODE_COMMON_RETRY_POLICY_16_004: [** The `getNextTimeout` method shall always return `-1`. **]**

### ExponentialBackoffWithJitter

#### shouldRetry(error)

**SRS_NODE_COMMON_RETRY_POLICY_16_006: [** The `shouldRetry` method of the new instance shall use the error filter passed to the constructor when the object was instantiated. **]**

#### getNextTimeout(currentRetryCount, isThrottled)

**SRS_NODE_COMMON_RETRY_POLICY_16_007: [** The `getNextTimeout` method shall implement the following math formula to determine the next timeout value: `F(x) = min(Cmin+ (2^(x-1)-1) * rand(C * (1 – Jd), C*(1-Ju)), Cmax` **]**

**SRS_NODE_COMMON_RETRY_POLICY_16_008: [** The `getNextTimeout` method shall return `0` instead of the result of the math formula if the following 3 conditions are met:
- the `constructor` was called with the `immediateFirstTimeout` boolean set to `true`
- the `isThrottled` boolean is `false`.
- the `currentRetryCount` is `0` (meaning it's the first retry). **]**

**SRS_NODE_COMMON_RETRY_POLICY_16_009: [** The default constants to use with the Math formula for the normal conditions retry are:
```
c = 100
cMin = 100
cMax = 10000
ju = 0.25
jd = 0.5
``` **]**

**SRS_NODE_COMMON_RETRY_POLICY_16_010: [** The default constants to use with the Math formula for the throttled conditions retry are:
```
c = 5000
cMin = 10000
cMax = 60000
ju = 0.5
jd = 0.25
``` **]**

repository: Azure/azure-iot-sdk-node

branch_name: refs/heads/main

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: Azure/azure-iot-sdk-node


text:
# [149. Max Points on a Line](https://leetcode-cn.com/problems/max-points-on-a-line/)

## 题目
Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

## 解题思路

见程序注释

![100%](149.100.png)

repository: imgoogege/LeetCode-in-Go

repo_name: imgoogege/LeetCode-in-Go


text:
# Development notes

The best way to work on Styledown is to run the example in `examples/bootstrap`:

```sh
make example
open http://localhost:3000
```

## Other languages

A ruby gem is published, `styledown2-source`, which contains the styledown source. The source is in `integrations/ruby/`.

A hex package is also published, `styledown2_source`. The source is in `integrations/elixir/`.

```sh
make rubygem          # Builds the rubygem
make hex              # Builds the hex package
make publish-rubygem  # Push to rubygems.org
make publish-hex      # Push to hex.pm
```


text:
*This repository is a mirror of the [component](http://component.io) module [viatropos/linkedin-share](http://github.com/viatropos/linkedin-share). It has been modified to work with NPM+Browserify. You can install it using the command `npm install npmcomponent/viatropos-linkedin-share`. Please do not open issues or send pull requests against this repo. If you have issues with this repo, report it to [npmcomponent](https://github.com/airportyh/npmcomponent).*
# Linkedin Share

## Installation

```bash
component install viatropos/linkedin-share
```

## Example

```js
var share = require('linkedin-share');

share('https://github.com', 'GitHub', 'The GitHub homepage', window.location);
```

## Notes

- http://platform.linkedin.com/in.js?async=true

```
IN.init({
    onLoad: "myOnloadFunction"
});
```

## Licence

MIT

repository: npmcomponent/viatropos-linkedin-share

repo_name: npmcomponent/viatropos-linkedin-share


text:
# BattleShip Game
 Java program for a 2 Player game of BattleShip

The game is played on two fields, each 10 X 10 squares. The columns are labeled A-J, and the rows are labeled 1-10. Each player's fleet of ships consists of one aircraft carrier, one battleship, one destroyer, one submarine and one cruiser. The size and shape of each ship is as follows:

Destroyer (2 squares):
Submarine (3 squares):
Cruiser (3 squares):
Battleship (4 squares):
Aircraft Carrier (5 squares):

Before the game starts, each player secretly places their ships anywhere on their own playing field. Ships cannot overlap one another, but may be placed either vertically or horizontally.

Players take turns to try to guess the location of the other's ships by naming a square (e.g. F7). The opponent declares the square to be a hit or a miss, depending on whether there is a ship occupying that square. When all the squares occupied by a particular ship have been guessed, the player must announce that that particular ship is sunk. A player keeps track of the hits and misses on a copy of the opponent's field.

During each player's turn, only their board is completely visible whereas the opponent's board only shows attacked squares, i.e. HITS (X) and MISSES (M).

The first player to sink all the other's ships is the winner.

Project UML : ![Project UML](https://user-images.githubusercontent.com/63100608/119877457-b037e080-bf46-11eb-8918-874f34590c80.png)

repository: sambarannnn/BattleShip-Game

repo_name: sambarannnn/BattleShip-Game


text:
# OPERATING SYSTEMS *(mangement techniques)*

### ALGORITHMS IN THIS REPOSITORY INCLUDE

####  a) MEMORY MANAGEMENT TECHNIQUES
- MFT (multiprogramming with fixed number of tasks)
- MVT (multiprogramming with a variable number of tasks)
- best-fit
- first-fit
- worst-fit
- paging

#### b) CPU SCHEDULING ALGORITHMS
- First-come-first-serve
- Round Robin
- Shortest-Job-First
- Priority
- Multi-Level Queue

#### C)DISK SCHEDULING ALGORITHMS

- First Come Fisrt Serve
- SCAN
- C_SCAN

#### METHOD OF INSTALLATION
To run these programs, you'll need to download and install the Java SE Development Kit (or JDK for short, and SE means Standard Edition). To run the programs, you'll either need a text editor or an IDE that supports Java (e.g. Intelli J ,NeatBeans, Vscode).

### RUN CODE
If you want to run the algorithms in an IDE or Text Editor. You should copy the entire contents of any of the algorithm into a project in the IDE or Text Editor, and then run the Main.java in the folder.


text:
# Flagging Website

![](flagging_site/static/images/og_preview.png)

**Our website is live at: [https://crwa-flagging.herokuapp.com/](https://crwa-flagging.herokuapp.com/)**

## Overview

This is the code base for the [Charles River Watershed Association's](https://crwa.org/) ("CRWA") flagging website. The flagging website hosts an interface for the CRWA's staff to monitor the outputs of a predictive model that determines whether it is reasonably safe to swim or boat in the Charles River.

This code base is built in Python 3.7+ and utilizes the Flask library heavily. The website can be run locally in development mode, and it can be deployed to Heroku using Gunicorn.

## For Developers and Maintainers

**[Read our documentation here.](https://codeforboston.github.io/flagging/)** Our documentation contains information on everything related to the website, including [first time setup](https://codeforboston.github.io/flagging/setup/).

## Credits

This website was built by volunteers at [Code for Boston](https://www.codeforboston.org/) in collaboration with the Charles River Watershed Association.

repository: danivalades/flagging

repo_name: danivalades/flagging


text:
# ssg

A Node-based static site generator

Usage:
- Single build: `ssg <source-dir> <base-url> <destination-dir>`
- Watch/dev build: `ssg-watch <source-dir> <base-url> <destination-dir>`

---

- Any `index.html` will be used as a Handlebars template for all Markdown files in the same directory, as well as subdirectories.
- Any `template.html` will wrap content and be inserted into the nearest index file.
- Any `*.md` file is parsed into `content` of the relevant template, and output as minified HTML as the named index file.
- Any CSS files will be minified using `clean-css`.
- Any JS files will be minified using `terser`.
- Any other file is copied over as-is to the destination.

repository: joshforisha/ssg

repo_name: joshforisha/ssg


text:
---
layout: "alicloud"
page_title: "Alicloud: alicloud_api_gateway_groups"
sidebar_current: "docs-alicloud-datasource-api_gateway-groups"
description: |-
    Provides a list of api groups to the user.
---

# alicloud\_api\_gateway\_groups

This data source provides the api groups of the current Alibaba Cloud user.

## Example Usage

```
data "alicloud_api_gateway_groups" "data_apigatway"{
  output_file = "outgroups"
}

output "first_group_id" {
  value = "${data.alicloud_api_gateway_groups.data_apigatway.groups.0.id}"
}
```

## Argument Reference

The following arguments are supported:

* `name_regex` - (Optional) A regex string to filter api gateway groups by name.
* `output_file` - (Optional) File name where to save data source results (after running `terraform plan`).

## Attributes Reference

The following attributes are exported in addition to the arguments listed above:
* `groups` - A list of api groups. Each element contains the following attributes:
  * `id` - API group ID, which is generated by the system and globally unique.
  * `name` - API group name.
  * `description` - API group description.
  * `region_id` - The ID of the region where the API group is located.
  * `sub_domain` - Second-level domain name automatically assigned to the API group.
  * `created_time` - Creation time (Greenwich mean time).
  * `modified_time` - Last modification time (Greenwich mean time).
  * `traffic_limit` - Upper QPS limit of the API group; default value: 500, which can be increased by submitting an application.
  * `billing_status` - Billing status.
	- NORMAL: The API group is normal.
	- LOCKED: Locked due to outstanding payment.
  * `illegal_status` - Locking in invalid state.
	- NORMAL: The API group is normal.
	- LOCKED: Locked due to illegality.

repository: alibaba/terraform-provider

extension: markdown

gha_language: Go

repo_name: alibaba/terraform-provider


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [8.0.4](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@8.0.3<EMAIL_ADDRESS>(2023-08-24)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [8.0.3](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@8.0.2<EMAIL_ADDRESS>(2023-08-17)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [8.0.2](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@8.0.1<EMAIL_ADDRESS>(2023-07-24)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [8.0.1](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@8.0.0<EMAIL_ADDRESS>(2023-07-20)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [8.0.0](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@7.0.1<EMAIL_ADDRESS>(2023-07-13)

### ⚠ BREAKING CHANGES

* updated `plugins/field-date` to TypeScript (#1705)

### Features

* updated `plugins/field-date` to TypeScript ([#1705](https://github.com/google/blockly-samples/issues/1705)) ([e5531ff](https://github.com/google/blockly-samples/commit/e5531fffe188ee361a16fe48ed126b34e51a8d30))

## [7.0.1](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@7.0.0<EMAIL_ADDRESS>(2023-07-06)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [7.0.0](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.17<EMAIL_ADDRESS>(2023-06-28)

### ⚠ BREAKING CHANGES

* update all plugins to use blockly-v10.0.0 (#1744)

### Features

* update all plugins to use blockly-v10.0.0 ([#1744](https://github.com/google/blockly-samples/issues/1744)) ([6cc88cb](https://github.com/google/blockly-samples/commit/6cc88cbef39d4ad664a668d3d46eb29ba7292f9c))

## [6.0.17](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.16<EMAIL_ADDRESS>(2023-06-22)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.16](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.15<EMAIL_ADDRESS>(2023-05-18)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.15](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.14<EMAIL_ADDRESS>(2023-05-11)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.14](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.13<EMAIL_ADDRESS>(2023-05-04)

### Bug Fixes

* replace scrollToVisible_ with standard centerOnBlock ([#1678](https://github.com/google/blockly-samples/issues/1678)) ([e54a7e2](https://github.com/google/blockly-samples/commit/e54a7e268d4fe64c36ac529086c1c48527d215cf))

## [6.0.13](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.12<EMAIL_ADDRESS>(2023-04-27)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.12](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.11<EMAIL_ADDRESS>(2023-03-23)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.11](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.10<EMAIL_ADDRESS>(2023-03-09)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.10](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.9<EMAIL_ADDRESS>(2023-03-02)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.9](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.8<EMAIL_ADDRESS>(2023-02-23)

### Bug Fixes

* remove prepublishOnly scripts ([#1579](https://github.com/google/blockly-samples/issues/1579)) ([27da6cd](https://github.com/google/blockly-samples/commit/27da6cd04c38f6ba417f4e7446bb6218c475448d))

## [6.0.8](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.7<EMAIL_ADDRESS>(2023-02-23)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.7](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.6<EMAIL_ADDRESS>(2023-02-16)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.6](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.5<EMAIL_ADDRESS>(2023-02-09)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.5](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.4<EMAIL_ADDRESS>(2023-01-26)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.4](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.3<EMAIL_ADDRESS>(2023-01-05)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.3](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.2<EMAIL_ADDRESS>(2022-12-15)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.2](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.1<EMAIL_ADDRESS>(2022-10-27)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.1](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@6.0.0<EMAIL_ADDRESS>(2022-10-13)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## [6.0.0](https://github.com/google/blockly-samples/compare/@blockly/plugin-workspace-search@5.0.22<EMAIL_ADDRESS>(2022-10-05)

### ⚠ BREAKING CHANGES

* update peer and devDependencies of all plugins to require Blockly v9 (#1314)

### Bug Fixes

* Added css documentation for workspace search plugin. ([#1282](https://github.com/google/blockly-samples/issues/1282)) ([5dd7d2d](https://github.com/google/blockly-samples/commit/5dd7d2d2bed3d1e4920e27b795a06fff08e85297))
* references to deprecated functions in v9 ([#1313](https://github.com/google/blockly-samples/issues/1313)) ([cb2e679](https://github.com/google/blockly-samples/commit/cb2e67987e0b62a77c26adc660cc6ade1ba67954))
* search bar should select all when focused ([#1287](https://github.com/google/blockly-samples/issues/1287)) ([c6c4d4a](https://github.com/google/blockly-samples/commit/c6c4d4a06dab02ef9bfc0dcaf4f1de9f5e5f2c2e))

### Miscellaneous Chores

* update peer and devDependencies of all plugins to require Blockly v9 ([#1314](https://github.com/google/blockly-samples/issues/1314)) ([03d4912](https://github.com/google/blockly-samples/commit/03d4912c42c8de0f30493037ccc28dddaea0f266))

## 5.0.22 (2022-08-11)

### Bug Fixes

* Remove the deprecated block-extension-tooltip ([#1215](https://github.com/google/blockly-samples/issues/1215)) ([a044478](https://github.com/google/blockly-samples/commit/a044478c86a73e3065bc866e427f175cbec6fc13))

## 5.0.21 (2022-08-04)

### Bug Fixes

* fix the name of the package of suggested-blocks ([#1214](https://github.com/google/blockly-samples/issues/1214)) ([35aa8ec](https://github.com/google/blockly-samples/commit/35aa8ec73a60a4eb5b1e80cb2fc71dcd83d05e27))

## 5.0.19 (2022-07-21)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## 5.0.18 (2022-07-06)

### Bug Fixes

* Update blockly-react to use functional components instead of class components. ([#1178](https://github.com/google/blockly-samples/issues/1178)) ([fa21187](https://github.com/google/blockly-samples/commit/fa21187cdbe4ec3a5c69f185540dd68a98eb69d7))

## 5.0.17 (2022-06-27)

### Bug Fixes

* Update package import for keyboard navigation demo ([#1170](https://github.com/google/blockly-samples/issues/1170)) ([69c1725](https://github.com/google/blockly-samples/commit/69c1725b775279fcc397dc178935208d5f42b08c))

## 5.0.16 (2022-06-21)

**Note:** Version bump only for package @blockly/plugin-workspace-search

## 5.0.15 (2022-06-08)

### Bug Fixes

* package versions to support patch releases ([#1150](https://github.com/google/blockly-samples/issues/1150)) ([e1ae378](https://github.com/google/blockly-samples/commit/e1ae378d779531621c3d948566257d069002963f))

## 5.0.14 (2022-06-02)

### Bug Fixes

* add git identity ([#1156](https://github.com/google/blockly-samples/issues/1156)) ([8d80924](https://github.com/google/blockly-samples/commit/8d809243b277375beb2ce75d4e157b5e17f78193))

repository: google/blockly-samples

repo_name: google/blockly-samples


text:
---
posttype: "product"
name: Rib T-shirt Charcoal
templateKey: product
id: 1
price: 25.00
weight: 1
image: "../rib_t-shirt_charcoal/rib_t-shirt_charcoal_front.jpg"
path: "/products/rib_t-shirt_charcoal/rib_t-shirt_charcoal"
date: "2017-11-07"
tags: ['t-shirt']
color: ['all','black']
details: ['Material: 50% Cotton & 50% Polyester', 'Size & fit:  Length: 70cm','Care: Warm machine wash.']
sizes: ['S','M','L','XL']
---

<!-- ![alt text](/products/black_100_polo/black_100_polo.jpg) -->

Product details

Burton Menswear make the case for trans-seasonal styling with their deep charcoal LS Rib T-Shirt.

Our model is wearing a size medium t-shirt. He is 185.4cm (6’1”) tall with a 101.6cm (40”) chest and a 81.3cm (32”) waist.

- Length: 70cm (size medium)
- Regular fit
- Soft ribbed cotton blend jersey; moderate stretch
- Charcoal marle
- Crew neckline
- Long sleeves

SKU: BU077AA31HZO

repository: danielballoch/Menco

repo_name: danielballoch/Menco


text:
WordPress plugin: Geo Query
=================

[![Build Status](https://travis-ci.org/birgire/geo-query.svg?branch=master)](https://travis-ci.org/birgire/geo-query)
[![GitHub license](https://img.shields.io/github/license/birgire/geo-query.svg)](https://github.com/birgire/geo-query/blob/master/LICENCE)
[![Packagist](https://img.shields.io/packagist/v/birgir/geo-query.svg)](https://packagist.org/packages/birgir/geo-query)

### Description

This plugin adds a support for the `geo_query` part of the `WP_query`.

It uses the Haversine SQL implementation by Ollie Jones (see [here](http://www.plumislandmedia.net/mysql/haversine-mysql-nearest-loc/)).

The plugin works on PHP 5.3+.

It supports the GitHub Updater.

Activate the plugin and you can use the `geo_query` parameter in all your `WP_Query` queries.

Few examples are here below, e.g. for the Rest API.

### Installation

Upload the plugin to the plugin folder and activate it.

To install dependencies with Composer (not required):

    composer install

or

    php composer.phar install

within our folder. See here for more information on how to install Composer.

Then play with the example below, in your theme or in a plugin.

Have fun ;-)

### Example - Basic `WP_Query` usage:

Here's an example of the supported input parameters of the `geo_query` part:

    $args = [
        'post_type'           => 'post',
        'posts_per_page'      => 10,
        'ignore_sticky_posts' => true,
        'orderby'             => [ 'title' => 'DESC' ],
        'geo_query'           => [
            'lat'                =>  64,                                // Latitude point
            'lng'                =>  -22,                               // Longitude point
            'lat_meta_key'       =>  'geo_lat',                         // Meta-key for the latitude data
            'lng_meta_key'       =>  'geo_lng',                         // Meta-key for the longitude data
            'radius'             =>  150,                               // Find locations within a given radius (km)
            'order'              =>  'DESC',                            // Order by distance
            'distance_unit'      =>  111.045,                           // Default distance unit (km per degree). Use 69.0 for statute miles per degree.
            'context'            => '\\Birgir\\Geo\\GeoQueryHaversine', // Default implementation, you can use your own here instead.
        ],
    ];
    $query = new WP_Query( $args );

### Example - Rest API usage:

Here's a modified example from @florianweich:

	add_filter( 'rest_query_vars', function ( $valid_vars ) {
		return array_merge( $valid_vars, [ 'geo_location' ] );
	} );

	add_filter( 'rest_post_query', function( $args, $request ) {
		$geo = json_decode( $request->get_param( 'geo_location' ) );
		if ( isset( $geo->lat, $geo->lng ) ) {
			$args['geo_query'] = [
				'lat'                =>  (float) $geo->lat,
				'lng'                =>  (float) $geo->lng,
				'lat_meta_key'       =>  'geo_lat',
				'lng_meta_key'       =>  'geo_lng',
				'radius'             =>  ($geo->radius) ? (float) $geo->radius : 50,
			];
		}
		return $args;
	}, 10, 2 );

Test it with e.g.:

	https://example.com/wp-json/wp/v2/posts?geo_location={"lat":"64.128288","lng":"-21.827774","radius":"50"}

One can use `rest_{custom-post-type-slug}_query` filter for a custom post type.

### Notes on the parameters:

 - The plugin assumes we store the latitudes and longitudes as custom fields ( post meta), so we need to tell the query about meta keys with the `'lat_meta_key'` and `'lng_meta_key'` parameters.

 - Skipping the `'radius'` parameter means that no distance filtering will take place.

 - If we use the `'order'` parameter within the `'geo_query'`, then it will be prepended to the native `'orderby'` parameter.

 - The `'distance_unit'` parameter should be `69.0` for distance in statute miles, else `111.045` for distance in kilometers.

 - If we want to use the optimized Haversine version by Ollie Jones, we use:

         'context' => '\\Birgir\\Geo\\GeoQueryHaversineOptimized'

   Notice that on our current plugin setup (i.e. fetching data from the LONGTEXT post meta fields) this isn't more performant than the default `GeoQueryHaversine` class.

   A future work could be to use a custom table with indexes, for the optimization to work.

 - If we create our own implementation of the Haversine formula, for example the `GeoQueryCustom` class, we just have to make sure it implements the `GeoQueryInterface` interface:

         'context' => 'GeoQueryCustom'

### Feedback

Any suggestions are welcomed.

### Changelog

0.0.7 (2018-06-27)
- Fixed #10. Use ^1.0.0 for composer installer. Props @wujekbogdan

0.0.6 (2017-11-16)
- Fixed #6. Support floating point radius. Props @wujekbogdan
- Added integration tests.

0.0.5 (2017-02-26)

- Added fallback for those that don't use Composer
- Removed the vendor directory

0.0.4 (2017-02-26)

- Fixed #4. Props @billzhong .

0.0.3 (2015-04-29)

- Fixed #2. Fixed a typo. Props @Ben764 and @con322.

0.0.2 (2015-03-10)

- Added: Support for the GitHub Updater.
- Updated: README.md
- Changed: Use distance_value instead of distance_in_km in SQL, since we can use miles by changing the distance_unit parameter.

0.0.1 - Init

repository: mihdan/geo-query

repo_name: mihdan/geo-query


text:
# Simple Substition Algorithm Decoder

In order to launch:

### Windows
1. Set `JAVA_HOME` environment variable to point to the Java 8 installation directory.
2. Navigate to the project folder and execute following command:
```dos
.\bin\activator run
```

### Linux and MacOS
1. Set `JAVA_HOME` environment variable to point to the Java 8 installation directory.
2. Navigate to the project folder and execute following command:
```bash
./bin/activator run
```


text:
# VMware protection - Example Workflow

## Connect to the Cohesity Cluster
First make sure that you are connected to a Cohesity Cluster
```powershell
Connect-CohesityCluster -Server cohesity-cluster -Credential (Get-Credential)
```

## Register a new vCenter with Cohesity
```powershell
$vcenter = Register-CohesityProtectionSourceVMware -Server vcenter-server -Type KVCenter -Credential (Get-Credential)
$vcenter
```

## Get a list of VMware VMs on the newly registered vCenter
```powershell
Get-CohesityVMwareVM -ParentSourceId $vcenter.Id
```

If you want to narrow down the selection by matching a pattern, you may do something like:
```powershell
$vms = Get-CohesityVMwareVM | Where-Object {$_.Name -match "linux"}
$vms
```

## Create a new protection job to protect the selected VMs
```powershell
New-CohesityProtectionJob -Name "linux-vms" -Description "Backup linux vms" -PolicyName "Bronze" -StorageDomainName "DefaultIddStorageDomain" -ParentSourceId $vms[0].ParentId -SourceIds ($vms).Id -Environment kVMware
```

We can check that the job was created properly
```powershell
$job = Get-CohesityProtectionJob -Names "linux-vms"
$job
```
The job would run automatically after it is created, by default.

You can monitor the job run using below:
```powershell
Get-CohesityProtectionJobRun -JobId $job.Id
```

## Restore the backed up VM to the original location
After the backup run is successful, we can restore a VM to its original location as shown below:
```powershell
$task = Restore-CohesityVMwareVM -TaskName "restore-task-linux" -SourceId $vms[0].Id -JobId $job.Id -VmNamePrefix "copy-"
$task
```

## Monitor the progress of the restore
```powershell
Get-CohesityRestoreTask -Ids $task.Id
```

repository: cohesity/cohesity-powershell-module

gha_language: C#

repo_name: cohesity/cohesity-powershell-module


text:
---
layout: post
title:  "100 Days of Swift - Day 45"
date:   2019-03-19 05:52:56 +1300
categories: ohdos
---
According to the rules for taking part in [100 Days of Swift](https://www.hackingwithswift.com/100), as soon as I've finished each day, I have to post about it.

The topic for Day 45 was: Project 11, Part One.

This consisted of: Setting up; Falling boxes: SKSpriteNode, UITouch, SKPhysicsBody; and Bouncing balls: circleOfRadius.

Fun stuff. Would help to have an iPad of some kind to run stuff on, but no way I can afford that at the moment.


text:
<!--
This file is part of BenchExec, a framework for reliable benchmarking:
https://github.com/sosy-lab/benchexec

SPDX-FileCopyrightText: 2007-2020 Dirk Beyer <https://www.sosy-lab.org>

SPDX-License-Identifier: Apache-2.0
-->

# BenchExec: runexec
## Benchmarking a Single Run

BenchExec provides a program called `runexec` that can be used to
easily execute a single command while measuring its resource consumption,
similarly to the tool `time` but with more reliable time measurements
and with measurement of memory usage.
To use it, simply pass as parameters the command that should be executed
(adding `--` before the command will ensure that the arguments to the command
will not be misinterpreted as arguments to `runexec`):

    runexec -- <cmd> <arg> ...

This will start the command, write its output to the file `output.log`,
and print resource measurements to stdout. Example:

    $ runexec echo Test
    2015-03-06 12:54:01,707 - INFO - Starting command echo Test
    2015-03-06 12:54:01,708 - INFO - Writing output to output.log
    returnvalue=0
    walltime=0.0024175643920898438s
    cputime=0.001671s
    memory=131072

For further details on the output, cf. [Run Results](run-results.md).

Resource limits can be enabled with additional arguments to `runexec`,
e.g. for CPU time (`--timelimit`), wall time (`--walltimelimit`),
or memory consumption (`--memlimit`). If any of the limits is exceeded,
the started command is killed forcefully (including any child processes it started).
Additionally, a "soft" limit can be given for CPU time (needs to be smaller than the real limit).
If given, the tool is sent the `TERM` signal after the soft limit is reached,
which will allow it to shutdown gracefully
(e.g., including writing output files and generating statistics)
before it is killed forcefully when the real time limit is reached.
For more information on how resources are measured and limited,
please refer to the general documentation on [resource handling](resources.md).

`runexec` can also restrict the executed command to a set of specific CPU cores
with the parameters `--cores`,
and (on NUMA systems) to specific memory regions with `--memoryNodes`.
The IDs used for CPU cores and memory regions are the same as used by the kernel
and can be seen in the directories `/sys/devices/system/cpu` and `/sys/devices/system/node`.

Additional parameters allow to change the name of the output file and the working directory.
The full set of available parameters can be seen with `runexec -h`.
For explanation of the parameters for containers, please see [container mode](container.md).
Command-line parameters can additionally be read from a file
as [described for benchexec](benchexec.md#starting-benchexec).

## Integration into other Benchmarking Frameworks

BenchExec can be used inside other benchmarking frameworks
for the actual command execution and handling of the resource limits and measurements.
To do so, simply use the `runexec` command in your benchmarking framework
as a wrapper around the actual command, and pass the appropriate command-line flags
for resource limits and read the resource measurements from the output.
If you want to bundle BenchExec with your framework,
you only need to use the `.whl` file for BenchExec,
no external dependencies are required.
You can also execute `runexec` directly from the `.whl` file with the following command
(no separate start script or installation is necessary):

    PYTHONPATH=path/to/BenchExec.whl python3 -m benchexec.runexecutor ...

From within Python, BenchExec can be used to execute a command as in the following example:

```python
from benchexec.runexecutor import RunExecutor
executor = RunExecutor()
result = executor.execute_run(args=[<TOOL_CMD>], ...)
```

Further parameters for `execute_run` can be used to specify resource limits
(c.f. [runexecutor.py](../benchexec/runexecutor.py)).
The result is a dictionary with the same information about the run
that is printed to stdout by the `runexec` command-line tool (cf. [Run Results](run-results.md)).

If `RunExecutor` is used on the main thread,
caution must be taken to avoid `KeyboardInterrupt`, e.g., like this:

```python
import signal
from benchexec.runexecutor import RunExecutor
executor = RunExecutor()

def stop_run(signum, frame):
  executor.stop()

signal.signal(signal.SIGINT, stop_run)

result = executor.execute_run(args=[<TOOL_CMD>], ...)
```

repository: sosy-lab/benchexec

gha_language: Python

repo_name: sosy-lab/benchexec


text:
# TOML
[![toml-badge]][toml]

Parse TOML into a `toml::Value` and then operate on it:

```rust
extern crate toml;

fn main() {

    let toml_source = "
        [package]
        name = \"your package!\"
        version = \"0.1.0\"
        authors = [\"You<EMAIL_ADDRESS>
        [dependencies]
        cool = \"0.2.1\"";

    let package_info = toml_source.parse::<toml::Value>().unwrap();

    assert_eq!(package_info["dependencies"]["cool"].as_str(), Some("0.2.1"));
    assert_eq!(package_info["package"]["name"].as_str(), Some("your package!"));

}
```

Parse TOML into your own structs using the `serde` crate:

```rust

extern crate toml;

#[macro_use]
extern crate serde_derive;
extern crate serde;

#[derive(Deserialize)]
struct Config {
    package: Package,
    dependencies: std::collections::HashMap<String, String>,
}

#[derive(Deserialize)]
struct Package {
    name: String,
    version: String,
    authors: Vec<String>,
}

fn main() {

    let toml_source = "
        [package]
        name = \"your package!\"
        version = \"0.1.0\"
        authors = [\"You<EMAIL_ADDRESS>
        [dependencies]
        cool = \"0.2.1\"";

    let package_info : Config = toml::from_str(toml_source).unwrap();

    assert_eq!(package_info.package.name, "your package!");
    assert_eq!(package_info.package.version, "0.1.0");
    assert_eq!(package_info.package.authors, vec!["You! <you@example.org>"]);
    assert_eq!(package_info.dependencies["cool"], "0.2.1");

}
```

# License

MIT/Apache-2.0

<!-- Links -->

[toml-badge]: https://img.shields.io/crates/v/rustc-serialize.svg?label=toml
[toml]: http://alexcrichton.com/toml-rs/toml/

repository: rofrol/rust-cookbook

repo_name: rofrol/rust-cookbook


text:
[//000000001]: # (map::slippy \- Mapping utilities)
[//000000002]: # (Generated from file 'map\_slippy\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (map::slippy\(n\) 0\.8 tcllib "Mapping utilities")

 [ Main Table Of Contents | Table Of Contents | Keyword Index | Categories | Modules | Applications ]

# NAME

map::slippy \- Common code for slippy based map packages

# Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [Coordinate systems](#section2)

      - [Geographic](#subsection1)

      - [Points](#subsection2)

  - [API](#section3)

  - [References](#section4)

  - [Keywords](#keywords)

# SYNOPSIS

package require Tcl 8\.6
package require map::slippy ?0\.8?

[__::map__ __slippy geo box 2point__ *zoom* *geobox*](#1)
[__::map__ __slippy geo box center__ *geobox*](#2)
[__::map__ __slippy geo box corners__ *geobox*](#3)
[__::map__ __slippy geo box diameter__ *geobox*](#4)
[__::map__ __slippy geo box dimensions__ *geobox*](#5)
[__::map__ __slippy geo box fit__ *geobox* *canvdim* *zmax* ?*zmin*?](#6)
[__::map__ __slippy geo box inside__ *geobox* *geo*](#7)
[__::map__ __slippy geo box limit__ *geobox*](#8)
[__::map__ __slippy geo box opposites__ *geobox*](#9)
[__::map__ __slippy geo box perimeter__ *geobox*](#10)
[__::map__ __slippy geo box valid__ *geobox*](#11)
[__::map__ __slippy geo box valid\-list__ *geoboxes*](#12)
[__::map__ __slippy geo distance__ *geo1* *geo2*](#13)
[__::map__ __slippy geo distance\*__ *closed* *geo*\.\.\.](#14)
[__::map__ __slippy geo distance\-list__ *closed* *geo\-list*](#15)
[__::map__ __slippy geo limit__ *geo*](#16)
[__::map__ __slippy geo bbox__ *geo*\.\.\.](#17)
[__::map__ __slippy geo bbox\-list__ *geo\-list*](#18)
[__::map__ __slippy geo center__ *geo*\.\.\.](#19)
[__::map__ __slippy geo center\-list__ *geo\-list*](#20)
[__::map__ __slippy geo diameter__ *geo*\.\.\.](#21)
[__::map__ __slippy geo diameter\-list__ *geo\-list*](#22)
[__::map__ __slippy geo 2point__ *zoom* *geo*](#23)
[__::map__ __slippy geo 2point\*__ *zoom* *geo*\.\.\.](#24)
[__::map__ __slippy geo 2point\-list__ *zoom* *geo\-list*](#25)
[__::map__ __slippy geo valid__ *geo*](#26)
[__::map__ __slippy geo valid\-list__ *geos*](#27)
[__::map__ __slippy length__ *level*](#28)
[__::map__ __slippy limit2__ *x*](#29)
[__::map__ __slippy limit3__ *x*](#30)
[__::map__ __slippy limit6__ *x*](#31)
[__::map__ __slippy point box 2geo__ *zoom* *pointbox*](#32)
[__::map__ __slippy point box center__ *pointbox*](#33)
[__::map__ __slippy point box corners__ *pointbox*](#34)
[__::map__ __slippy point box diameter__ *pointbox*](#35)
[__::map__ __slippy point box dimensions__ *pointbox*](#36)
[__::map__ __slippy point box inside__ *pointbox* *point*](#37)
[__::map__ __slippy point box opposites__ *pointbox*](#38)
[__::map__ __slippy point box perimeter__ *pointbox*](#39)
[__::map__ __slippy point distance__ *point1* *point2*](#40)
[__::map__ __slippy point distance\*__ *closed* *point*\.\.\.](#41)
[__::map__ __slippy point distance\-list__ *closed* *point\-list*](#42)
[__::map__ __slippy point bbox__ *point*\.\.\.](#43)
[__::map__ __slippy point bbox\-list__ *point\-list*](#44)
[__::map__ __slippy point center__ *point*\.\.\.](#45)
[__::map__ __slippy point center\-list__ *point\-list*](#46)
[__::map__ __slippy point diameter__ *point*\.\.\.](#47)
[__::map__ __slippy point diameter\-list__ *point\-list*](#48)
[__::map__ __slippy point 2geo__ *zoom* *point*](#49)
[__::map__ __slippy point 2geo\*__ *zoom* *point*\.\.\.](#50)
[__::map__ __slippy point 2geo\-list__ *zoom* *point\-list*](#51)
[__::map__ __slippy point simplify radial__ *threshold* *point\-list*](#52)
[__::map__ __slippy point simplify rdp__ *point\-list*](#53)
[__::map__ __slippy pretty\-distance__ *x*](#54)
[__::map__ __slippy tiles__ *level*](#55)
[__::map__ __slippy tile size__](#56)
[__::map__ __slippy tile valid__ *zoom* *row* *column* *levels* ?*msgvar*?](#57)
[__::map__ __slippy valid latitude__ *x*](#58)
[__::map__ __slippy valid longitude__ *x*](#59)

# DESCRIPTION

This package provides a number of methods doing things needed by all types of
slippy\-based map packages\.

*BEWARE*, *Attention* Version *0\.8* is *NOT backward compatible* with
version 0\.7 and earlier\. The entire API was *heavily revised and changed*\.

*Note:* For the representation of locations in the various coordinate systems
used by the commands of this package please read section [Coordinate
systems](#section2)\. The command descriptions will not repeat them, and
assume that they are understood already\.

# Coordinate systems

The commands of this package operate in two distinct coordinate systems,
geographical locations, and points\. The former represents coordinates for
locations on Earth, while the latter is for use on Tk *canvas* widgets\.

## Geographic

Geographical locations \(short: *geo*\) are represented by a pair of
*Latitude* and *[Longitude](\.\./\.\./\.\./\.\./index\.md\#longitude)* values,
each of which is measured in degrees, as they are essentially angles\.

The __Zero__ longitude is the *Greenwich meridian*, with positive values
going *east*, and negative values going *west*, for a total range of \+/\- 180
degrees\. Note that \+180 and \-180 longitude are the same *meridian*, opposite
to Greenwich\.

The __zero__ latitude is the *Equator*, with positive values going
*north* and negative values going *south*\. While the true range is \+/\- 90
degrees the projection used by the package requires us to cap the range at
roughly \+/\- __85\.05112877983284__ degrees\. This means that the North and
South poles are not representable and not part of any map\.

A geographical location is represented by a list containing two values, the
latitude, and longitude of the location, in this order\.

A geographical bounding box is represented by a list containing four values, the
minimal latitude and longitude of the box, and the maximal latitude and
longitude of the box, in this order\.

Geographical locations and boxes can be converted to points and their boxes by
means of an additional parameter, the *[zoom](\.\./\.\./\.\./\.\./index\.md\#zoom)*
level\. This parameter indicates the size of the map in the canvas the
coordinates are to be projected into\.

## Points

Points \(short: *[point](\.\./\.\./\.\./\.\./index\.md\#point)*\) are represented by a
pair of *x* and *y* values, each of which is measured in pixels\. They
reference a location in a Tk *canvas* widget\. As a map can be shown at
different degrees of magnification, the exact pixel coordinates for a
geographical location depend on this *[zoom](\.\./\.\./\.\./\.\./index\.md\#zoom)*
level\.

For the following explanation to make sense it should be noted that a map shown
in a Tk *canvas* widget is split into equal\-sized quadratic *tiles*\.

Point coordinates are tile coordinates scaled by the size of these tiles\. This
package uses tiles of size __256__, which is the standard size used by many
online servers providing map tiles of some kind or other\.

A point is represented by a list containing the x\- and y\-coordinates of the
lcoation, in this in this order\.

A point bounding box is represented by a list containing four values, the
minimal x and y of the box, and the maximal x and y of the box, in this order\.

Point locations and boxes can be converted to geographical locations and their
boxes by means of an additional parameter, the
*[zoom](\.\./\.\./\.\./\.\./index\.md\#zoom)* level\. This parameter indicates the
size of the map in the canvas the coordinates are projected from\.

Tile coordinates appear only in one place of the API, in the signature of
command __map slippy tile valid__\. Everything else uses Point coordinates\.

Using tile coordinates in the following however makes the structure of the map
at the various *[zoom](\.\./\.\./\.\./\.\./index\.md\#zoom)* levels \(maginification
factors\) easier to explain\.

Generally the integer part of the tile coordinates represent the row and column
number of a tile of the map, wheras the fractional parts signal how far inside
that tile the location in question is, with pure integer coordinates \(no
fractional part\) representing the upper left corner of a tile\.

The zero point of the map is at the upper left corner, regardless of zoom level,
with larger coordinates going right \(east\) and down \(south\), and smaller
coordinates going left \(west\) and up \(north\)\. Again regardless of zoom level\.

Negative coordinates are not allowed\.

At zoom level __0__ the entire map is represented by a single tile, putting
the geographic zero at 1/2, 1/2 in terms of tile coordinates, and the range of
tile coordinates as \[0\.\.\.1\]\.

When going from zoom level __N__ to the next deeper \(magnified\) level
\(__N__\+1\) each tile of level __N__ is split into its four quadrants,
which then are the tiles of level __N__\+1\.

This means that at zoom level __N__ the map is sliced \(horizontally and
vertically\) into __2^N__ rows and columns, for a total of __4^N__ tiles,
with the tile coordinates ranging from __0__ to __2^N\+1__\.

# API

  - __::map__ __slippy geo box 2point__ *zoom* *geobox*

    The command converts the geographical box *geobox* to a point box in the
    canvas, for the specified *zoom* level, and returns that box\.

  - __::map__ __slippy geo box center__ *geobox*

    The command returns the center of the geographical box *geobox*\.

  - __::map__ __slippy geo box corners__ *geobox*

    This command returns a list containing the four corner locations implied by
    the geographical box *geobox*\. The four points are top\-left, bottom\-left,
    top\-right, and bottom\-right, in that order\.

  - __::map__ __slippy geo box diameter__ *geobox*

    The command returns the diameter of the geographical box *geobox*, in
    meters\.

  - __::map__ __slippy geo box dimensions__ *geobox*

    The command returns the dimensions of the geographical box *geobox*, width
    and height, in this order\.

  - __::map__ __slippy geo box fit__ *geobox* *canvdim* *zmax* ?*zmin*?

    This command calculates the zoom level such that the *geobox* will fit
    into a viewport given by *canvdim* \(a 2\-element list containing the width
    and height of said viewport\) and returns it\.

    The zoom level will be made to fit within the range *zmin*\.\.\.*zmax*\.
    When *zmin* is not specified it will default to __0__\.

  - __::map__ __slippy geo box inside__ *geobox* *geo*

    The command tests if the geographical location *geo* is contained in the
    geographical box *geobox* or not\. It returns __true__ if so, and
    __false__ else\.

  - __::map__ __slippy geo box limit__ *geobox*

    This command limits the geographical box to at most 6 decimals and returns
    the result\.

    For geographical coordinates 6 decimals is roughly equivalent to a grid of
    11\.1 cm\.

  - __::map__ __slippy geo box opposites__ *geobox*

    This command returns a list containing the two principal corner locations
    implied by the geographical box *geobox*\. The two points are top\-left, and
    bottom\-right, in that order\.

  - __::map__ __slippy geo box perimeter__ *geobox*

    The command returns the perimeter of the geographical box *geobox*, in
    meters\.

  - __::map__ __slippy geo box valid__ *geobox*

    This commands tests if the specified geographical box contains only valid
    latitudes and longitudes\. It returns __true__ if the box is valid, and
    __false__ else\.

  - __::map__ __slippy geo box valid\-list__ *geoboxes*

    This commands tests if the list of geographical boxes contains only valid
    latitudes and longitudes\. It returns __true__ if all the boxes are
    valid, and __false__ else\.

  - __::map__ __slippy geo distance__ *geo1* *geo2*

    This command computes the great\-circle distance between the two geographical
    locations in meters and returns that value\.

    The code is based on
    [https://wiki\.tcl\-lang\.org/page/geodesy](https://wiki\.tcl\-lang\.org/page/geodesy)
    take on the [haversine
    formula](https://en\.wikipedia\.org/wiki/Haversine\_formula)\.

  - __::map__ __slippy geo distance\*__ *closed* *geo*\.\.\.

    An extension of __map slippy geo distance__ this command computes the
    cumulative distance along the path specified by the ordered set of
    geographical locations in meters, and returns it\.

    If the path is marked as *closed* \(i\.e\. a polygon/loop\) the result
    contains the distance between last and first element of the path as well,
    making the result the length of the perimeter of the area described by the
    locations\.

  - __::map__ __slippy geo distance\-list__ *closed* *geo\-list*

    As a variant of __map slippy geo distance\*__ this command takes the path
    to compute the length of as a single list of geographical locations, instead
    of a varying number of arguments\.

  - __::map__ __slippy geo limit__ *geo*

    This command limits the geographical location to at most 6 decimals and
    returns the result\.

    For geographical coordinates 6 decimals is roughly equivalent to a grid of
    11\.1 cm\.

  - __::map__ __slippy geo bbox__ *geo*\.\.\.

  - __::map__ __slippy geo bbox\-list__ *geo\-list*

    These two commands compute the bounding box for the specified set of
    geographical locations and return a geographical box\.

    When no geographical locations are specified the box is "__0 0 0 0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy geo center__ *geo*\.\.\.

  - __::map__ __slippy geo center\-list__ *geo\-list*

    These two commands compute the center of the bounding box for the specified
    set of geographical locations\.

    When no geographical locations are specified the center is "__0 0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy geo diameter__ *geo*\.\.\.

  - __::map__ __slippy geo diameter\-list__ *geo\-list*

    These two commands compute the diameter for the specified set of
    geographical locations, in meters\. The diameter is the maximum of the
    pair\-wise distances between all locations\.

    When less than two geographical locations are specified the diameter is
    "__0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy geo 2point__ *zoom* *geo*

    This command converts the geographical location *geo* to a point in the
    canvas, for the specified *zoom* level, and returns that point\.

  - __::map__ __slippy geo 2point\*__ *zoom* *geo*\.\.\.

  - __::map__ __slippy geo 2point\-list__ *zoom* *geo\-list*

    These two commands are extensions of __map slippy geo 2point__ which
    take a series of geographical locations as either a varying number of
    arguments or a single list, convert them all to points as per the specified
    *zoom* level and return a list of the results\.

  - __::map__ __slippy geo valid__ *geo*

    This commands tests if the specified geographical location contains only
    valid latitudes and longitudes\. It returns __true__ if the location is
    valid, and __false__ else\.

  - __::map__ __slippy geo valid\-list__ *geos*

    This commands tests if the list of geographical locations contains only
    valid latitudes and longitudes\. It returns __true__ if all the locations
    are valid, and __false__ else\.

  - __::map__ __slippy length__ *level*

    This command returns the width/height of a slippy\-based map at the specified
    zoom *level*, in pixels\. This is, in essence, the result of

        expr { [tiles $level] * [tile size] }

  - __::map__ __slippy limit2__ *x*

  - __::map__ __slippy limit3__ *x*

  - __::map__ __slippy limit6__ *x*

    This command limits the value to at most 2, 3, or 6 decimals and returns the
    result\.

    For geographical coordinates 6 decimals is roughly equivalent to a grid of
    11\.1 cm\.

  - __::map__ __slippy point box 2geo__ *zoom* *pointbox*

    The command converts the point box *pointbox* to a geographical box in the
    canvas, as per the specified *zoom* level, and returns that box\.

  - __::map__ __slippy point box center__ *pointbox*

    The command returns the center of the *pointbox*\.

  - __::map__ __slippy point box corners__ *pointbox*

    This command returns a list containing the four corner locations implied by
    the point box *pointbox*\. The four points are top\-left, bottom\-left,
    top\-right, and bottom\-right, in that order\.

  - __::map__ __slippy point box diameter__ *pointbox*

    The command returns the diameter of the *pointbox*, in pixels\.

  - __::map__ __slippy point box dimensions__ *pointbox*

    The command returns the dimensions of the *pointbox*, width and height, in
    this order\.

  - __::map__ __slippy point box inside__ *pointbox* *point*

    The command tests if the *point* is contained in the *pointbox* or not\.
    It returns __true__ if so, and __false__ else\.

  - __::map__ __slippy point box opposites__ *pointbox*

    This command returns a list containing the two principal corner locations
    implied by the point box *pointbox*\. The two points are top\-left, and
    bottom\-right, in that order\.

  - __::map__ __slippy point box perimeter__ *pointbox*

    The command returns the perimeter of the *pointbox*, in pixels\.

  - __::map__ __slippy point distance__ *point1* *point2*

    This command computes the euclidena distance between the two points in
    pixels and returns that value\.

  - __::map__ __slippy point distance\*__ *closed* *point*\.\.\.

    An extension of __map slippy point distance__ this command computes the
    cumulative distance along the path specified by the ordered set of points,
    and returns it\.

    If the path is marked as *closed* \(i\.e\. a polygon/loop\) the result
    contains the distance between last and first element of the path as well,
    making the result the length of the perimeter of the area described by the
    locations\.

  - __::map__ __slippy point distance\-list__ *closed* *point\-list*

    As a variant of __map slippy point distance\*__ this command takes the
    path to compute the length of as a single list of points, instead of a
    varying number of arguments\.

  - __::map__ __slippy point bbox__ *point*\.\.\.

  - __::map__ __slippy point bbox\-list__ *point\-list*

    These two commands compute the bounding box for the specified set of points
    and return a point box\.

    When no points are specified the box is "__0 0 0 0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy point center__ *point*\.\.\.

  - __::map__ __slippy point center\-list__ *point\-list*

    These two commands compute the center of the bounding box for the specified
    set of points\.

    When no points are specified the center is "__0 0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy point diameter__ *point*\.\.\.

  - __::map__ __slippy point diameter\-list__ *point\-list*

    These two commands compute the diameter for the specified set of points, in
    pixels\. The diameter is the maximum of the pair\-wise distances between all
    locations\.

    When less than two points are specified the diameter is "__0__"\.

    The locations are specified as either a varying number of arguments, or as a
    single list\.

  - __::map__ __slippy point 2geo__ *zoom* *point*

    This command converts the *point* in the canvas, for the specified
    *zoom* level, to a geograhical location, and returns that location\.

  - __::map__ __slippy point 2geo\*__ *zoom* *point*\.\.\.

  - __::map__ __slippy point 2geo\-list__ *zoom* *point\-list*

    These two commands are extensions of __map slippy point 2geo__ which
    take a series of points as either a varying number of arguments or a single
    list, convert them all to geographical locations as per the specified
    *zoom* level and return a list of the results\.

  - __::map__ __slippy point simplify radial__ *threshold* *point\-list*

    This command takes a path of points \(as a single list\), simplifies the path
    using the *Radial Distance* algorithm and returns the simplified path as
    list of points\.

    In essence the algorithm keeps only the first of adjacent points nearer to
    that first point than the threshold, and drops the others\.

  - __::map__ __slippy point simplify rdp__ *point\-list*

    This command takes a patch of points \(as a single list\), simplifies it using
    the *non\-parametric* *Ramer\-Douglas\-Peucker* algorithm and returns the
    simplified path as list of points\.

  - __::map__ __slippy pretty\-distance__ *x*

    This methods formats the distance *x* \(in meters\) for display and returns
    the resulting string \(including the chosen unit\)\.

    Sub\-kilometer distances are limited to 2 decimals, i\.e\. centimeters, whereas
    Kilometers are limited to 3 decimals, i\.e\. meters\.

  - __::map__ __slippy tiles__ *level*

    This command returns the width/height of a slippy\-based map at the specified
    zoom *level*, in *tiles*\.

  - __::map__ __slippy tile size__

    This command returns the width/height of a tile in a slippy\-based map, in
    pixels\.

  - __::map__ __slippy tile valid__ *zoom* *row* *column* *levels* ?*msgvar*?

    This command checks if the tile described by *zoom*, *row*, and
    *column* is valid for a slippy\-based map having that many zoom *levels*,
    or not\. The result is a boolean value, __true__ if the tile is valid,
    and __false__ otherwise\. In the latter case a message is left in the
    variable named by *msgvar*, should it be specified\.

  - __::map__ __slippy valid latitude__ *x*

    This commands tests if the argument *x* is a valid latitude value, and
    returns the boolean result of that test\. I\.e\. __true__ if the value is
    valid, and __false__ else\.

  - __::map__ __slippy valid longitude__ *x*

    This commands tests if the argument *x* is a valid longitude value, and
    returns the boolean result of that test\. I\.e\. __true__ if the value is
    valid, and __false__ else\.

# References

  1. [http://wiki\.openstreetmap\.org/wiki/Main\_Page](http://wiki\.openstreetmap\.org/wiki/Main\_Page)

# KEYWORDS

[geodesy](\.\./\.\./\.\./\.\./index\.md\#geodesy),
[geography](\.\./\.\./\.\./\.\./index\.md\#geography),
[latitute](\.\./\.\./\.\./\.\./index\.md\#latitute),
[location](\.\./\.\./\.\./\.\./index\.md\#location),
[longitude](\.\./\.\./\.\./\.\./index\.md\#longitude),
[map](\.\./\.\./\.\./\.\./index\.md\#map), [slippy](\.\./\.\./\.\./\.\./index\.md\#slippy),
[zoom](\.\./\.\./\.\./\.\./index\.md\#zoom)

license: TCL

repository: tcltk/tcllib

gha_language: Tcl

repo_name: tcltk/tcllib


text:
# Test Build

#### Download

https://drive.google.com/open?id=0B-gPKiJYuKuITld4dzhuTC1WWWM

https://onedrive.live.com/redir?resid=604D4754F64B0ABC!4140&authkey=!ANUm9V3vTPmEFNI&ithint=folder%2c7z

#### New Features

- MPEG2DecPlus filter added to open d2v files with AviSynth+
- VCEncC added --check-features --codec --enforce-hrd --filler --fullrange --ltr --pre-analysis --ref --tier --vbaq
- x265 added --me sea --dynamic-rd --scenecut-bias --lookahead-threads --opt-cu-delta-qp --multi-pass-opt-analysis --multi-pass-opt-distortion --multi-pass-opt-rps --aq-motion --ssim-rd --hdr --hdr-opt --refine-level --limit-sao
- added 'Loop Fiter' tab to the x265 options dialog
- icons added to menus and menu editor
- QSVEncC added --profile main10
- colour_primaries added to MediaInfo Folder View
- NVEncC added --lookahead --cbrhq --vbrhq --aq-temporal --no-b-adapt --i-adapt --output-depth --strict-gop --vbr-quality --vpp-gauss --vpp-knn --vpp-pmd --device --preset --direct --adapt-transform --enable-ltr
- added the possibility to use different x265 options in first and second pass
- added setting 'Snap to desktop edges'
- added option to extract timecodes file from MKV (Options > Misc, disabled by default)
- added timecodes file option to muxer dialog, can be TXT or MKV
- added support for hardcoded subtitles using VapourSynth for srt, ass, idx/vobsub, sup/pgs

#### Fixed Bugs

- format 'E-AC3 EX' was unknown to eac3to demuxer
- fixed x265 command line generation for --limit-tu
- added missing check if Visual C++ 2012 is installed when masktools2, SangNom2 or VCEEncC are used
- nnedi3 wasn't loaded using avs nnedi3_rpow2
- in the scripting/code editor it was often needed to right-click a second time until the context menu showed
- fixed incompatible format like wmv being passed to mkvmerge and mp4box
- KNLMeansCL wasn't loaded for HAvsFunc/SMDegrain
- fixed x265 context help using right-click due to changed x265 URL
- fixed wrong stream used for audio encoding using eac3to when audio source file is mkv
- PCM wasn't demuxed from MP4/MOV files
- shutdown was broken on creators update
- changed x264 qpmin default value from 10 to 0
- fixed more then one hardcoded subtitle is added to the script automatically
- snap to desktop edges not working properly
- fixed bug using UNC paths
- copy to clipboard in MediaInfo dialog did not work

#### Tweaks

- menu item height increased
- added colorspace = "YV12" default everywhere FFVideoSource is used to open 10Bit sources, profiles have not been reset
- antialiased font rendering added in some places
- ensuring form show within the bounds of the working area (screen)
- reduce CPU time while encoding
- the message for low disk space is shown only once before jobs are created
- idx/srt/ass renderer for avs/vs is now HomeOfVapourSynthEvolution/VSFilterMod
- in case there are more then ten audio files or streams a sub menu is used
- audio file detection prefers now dtsma and thd files
- filter context menus open a lot quicker

#### Updated Tools

- QSVEncC 2.62
- masktools2 2.2.2
- VCEEncC 3.06
- HAvsFunc 2017-03-06
- x264 2762
- MediaInfo 0.7.93
- ffmpeg 3.2.2
- qaac 2.62
- L-SMASH-Works (avs) 929
- vslsmashsource (vs) 929
- KNLMeansCL 1.0.2
- NVEncC 3.07
- RgTools (avs) 0.95
- AviSynth+ 2455
- VapourSynth 37
- x265 2.3+30
- mkvtoolnix 10.0.0
- ffms2 2.2000 test3
- mvtools (vs) 18
- VSFilterMod (avs, vs) 4

repository: amccool/staxrip

gha_language: Visual Basic

repo_name: amccool/staxrip


text:
# Væv Platform 1.0
An advanced malware framework for Windows.

# Description
Væv is an open-source malware framework for pentesting. We currently only provide 3 methods but these are quite useful incase you want quick, secure and fast access to a computer.
* Key-logger
* Reverse-shell
* Shutdown computer

# Showcase
![dashboard](https://github.com/justvmexit/vaev/blob/main/showcase/dashboard.PNG)
![dashboard](https://github.com/justvmexit/vaev/blob/main/showcase/machine.PNG)
![dashboard](https://github.com/justvmexit/vaev/blob/main/showcase/action.PNG)

# Compiling
You need to recompile the node_modules and simply use x64-Release for the [client](https://github.com/justvmexit/vaev/tree/main/client)

# Using the malware
To use the malware you use netcat.
`nc -lvp <port>`
The port for reverse-shell's is 5420 and key-loggers are 5520
Then you just go on the website and issue an action for either.

# Credits
@Softnio - Thank you for the theme!

# License
Code released under MIT LICENSE.

repository: ALEHACKsp/vaev

repo_name: ALEHACKsp/vaev


text:
# UIKit | UIPageViewController extends UIViewController

A container view controller that manages navigation between pages of content, where each page is managed by a child view controller.

```typescript

/**
 * Initializes a newly created page view controller.
 */
constructor(isVertical?: boolean)

/**
 * If page-items setted, and loops sets to true, the page-viewcontroller enters infinite loops mode.
 * eg: when user scroll to last page, the next page is the page-items first page.
 */
loops: boolean = false

/**
 * Set static items for page-viewcontroller.
 */
pageItems: UIViewController[]

/**
 * Sets current page.
 */
currentPage: UIViewController | undefined

/**
 * Scrolls to next page.
 */
scrollToNextPage(animated?: boolean = true): void

/**
 * Scrolls to previous page.
 */
scrollToPreviousPage(animated?: boolean = true): void

/**
 * Returns the view controller before the given view controller.
 */
on('beforeViewController', (currentPage: UIViewController) => UIViewController | undefined): this

/**
 * Returns the view controller after the given view controller.
 */
on('afterViewController', (currentPage: UIViewController) => UIViewController | undefined): this

/**
 * Called after a gesture-driven transition completes.
 */
on('didFinishAnimating', (currentPage: UIViewController, previousPage: UIViewController) => void): this

```

repository: XTStudio/api

repo_name: XTStudio/api


text:
## Updates [12/26/2014]:
CloudTranscode will be back in 2015 I believe. The sight on this coming year looks promising.
Happy new year to all and good hacking :)

### Note:
I am focusing on another technical part of my company. I can't work on CloudTranscode at the moment. If you have time and want to pick up where I left off, get in touch with me! I will gladly guide you through it.

### TODO
   - Improve Thumbnails generation
   - Transcode images, audio, documents
   - Perform video split/transcode/merge
   - Finish Travis test
   - Normalize code

# What is Cloud Transcode ?
Cloud Transcode is a custom distributed transcoding stack using Amazon AWS services.

The goal of this project is to create an open source, scalable and cheap distributed transcoding platform where users have complete control over
performance and cost.

We start with video transcoding which is the most costly, but the goal is to transcode any media (audio, documents and images). We use FFMpeg for video transcoding.

Today's commercial solutions for video transcoding are very expensive for large volumes. With this solution you can transcode large quantity of videos at the pace you want, thus controling your cost.

With Cloud Transcode, you control: scale, speed and cost. You can run everything locally if you want, no Cloud instance required. You only need an Amazon AWS account and an Internet connection to use the required Amazon services: SWF, SQS and S3.

It means that you can have a local, hybrid or full cloud setup on Amazon Ec2 instances, it's up to you.

# Transcoding supported
- **Video to Video transcoding**: One video IN, many videos OUT. Any formats and codecs supported by your ffmpeg.
- **Video to Thumbnails transcoding**: Snapshot at certain time in video or intervals snapshot every N seconds.
- **Watermark integration in video**: Take image IN and position a watermark on top of the video. Custom position and transparency.

# High Level Architecture
![Alt text](/../images/high_level_arch.png?raw=true "High Level Architecture")

# Quick start with Vagrant
A Vagrant box (Virtual Machine) which provides pre-configured environment to run the stack has been created to help you test the stack and work on it. You can use Vagrant on any OS and quickly bootstrap.

See: https://sportarchive.hackpad.com/Cloud-Transcode-project-poG8vKTC16J#:h=Quick-start-with-Vagrant

# More info
Find the detailed documentation here: https://sportarchive.hackpad.com/Cloud-Transcode-project-poG8vKTC16J

## FFMpeg performance benchmark on Amazon EC2
Download the spreadsheet to compare the different Amazon EC2 instances cost and performances:
https://github.com/sportarchive/CloudTranscode/blob/master/benchmark/benchmark-aws-ffmpeg.xlsx

repository: Watch-Video/CloudTranscodeParallel

repo_name: Watch-Video/CloudTranscodeParallel


text:
# Building TSMP #

These are example builds of TSMP that are frequently tested.

## Build script of TSMP

To get information about TSMP build options for different version
using standalone or different combination of model components on
different machines inside the folder `TSMP/bldsva` execute

``` bash
	./build_tsmp.ksh -a
```

you can also use `--man` or `--help` to get terrsysmp build options

``` bash
	./build_tsmp.ksh --man ./build_tsmp.ksh --help
```

for building `TSMP` with COSMO-CLM3.5-ParFlow the following combination is recommended:
-   `-c clm3-cos5-pfl ` (recommended).

for building `TSMP-PDAF` the following combinations can be used:
-   `-c clm3-cos4-pfl-pdaf`
-   `-c clm3-cos5-pfl-pdaf` (recommended).

### Building on GPU

For building ParFlow 3.12 on GPU:

```shell
cd $TSMP_DIR/bldsva
./build_tsmp.ksh -c clm3-cos5-pfl -m JUWELS -O Intel -A GPU
```

## Build Examples

```{toctree}
---
maxdepth: 3
---
build_examples_tsmp.md
build_examples_tsmppdaf.md
```

## Patching the original source code

In order to prepare the original Cosmo5_1 source code for coupling, the Cosmo source code is patched using the diff files which are located in `$TSMP_DIR/bldsva/intf_oas3/cosmo5_1/pfile`.
The diff files are generated using the script `fpatch.sh` which is located in the same directory. Note that the patching is done only for cosmo5_1 source code.
If the user aims to modify the coupling source files, should modify the files located in `$TSMP_DIR/bldsva/intf_oas3/cosmo5_1/tsmp` and run again the script `fpatch.sh` in order to generate the the new diff files accordingly.
The necessary changes for making the ParFlow3.12 ready for coupling are already included in the official ParFlow3.12 release.
The changed source files for CLM3.5 are located in  `$TSMP_DIR/bldsva/intf_oas3/clm3_5/tsmp` and will be copied by TSMP scripts to the user's source code directory of CLM3.5 '(`bld/usr.src`)

## Automatic Porting of TSMP on x86 machines

The users who want to port TSMP on GENERIC_X86 Linux, the TSMP team provided a script to install all the necessary libraries (Netcdf, GRIBAPI, OpenMPI, HDF5, TCL, Hypre and Silo) automatically in TSMP root directory. Please run the script "lib_install.sh" located in bldsva directory to install the libraries. Note that if you exported already one of the libraries Netcdf, HDF5, GRIBAPI, Silo, Hypre and TCL in the .baschrc or .profile, you need to comment them out in order to not mess up the installation via the script lib_install.sh.

The instruction on how to build and how to configure TSMP for the cordex test case ([EURO-CORDEX test case experiment](./../gettingstarted.md/#the-fully-coupled-pan-european-euro-cordex-evaluation-experiment-with-tsmp)) are given in [step 5 ](./../gettingstarted.md/#step-5-build-tsmp-interface-and-component-models) and [step 6 ](./../gettingstarted.md/#step-6-setup-and-configuration-of-the-respective-usage-and-test-case) in the getting started section, respectively.

repository: HPSCTerrSys/TSMP

gha_language: Fortran

repo_name: HPSCTerrSys/TSMP


text:
# Sheets of Paper

Emulating real sheets of paper in web documents (using HTML and CSS)

[**Live demo**](https://delight-im.github.io/HTML-Sheets-of-Paper/): Try printing the page

## Paper sizes

 * `A4` (21cm × 29.7cm) — `sheets-of-paper-a4.css`
 * `A3` (29.7cm × 42cm) — `sheets-of-paper-a3.css`
 * `US Letter` (21.6cm × 27.9cm) — `sheets-of-paper-usletter.css`
 * `US Legal` (21.6cm × 35.6cm) — `sheets-of-paper-uslegal.css`
 * `US Tabloid` (27.9cm × 43.2cm) — `sheets-of-paper-ustabloid.css`

## Printing

### Chrome

 * Change the `Destination` to `Save as PDF`.
 * Make sure the `Paper size` is set to the one defined in your CSS.
 * From the `Margins` list, choose `None` to prevent the browser from overriding our CSS.
 * In the `Options` section, uncheck `Headers and footers` and check `Background colors and images`.

## Third-party components

 * Open Sans — Steve Matteson (via Google) — Apache License 2.0

## License

```
Copyright 2014 www.delight.im<EMAIL_ADDRESS>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

repository: diycp/HTML-Sheets-of-Paper

branch_name: refs/heads/gh-pages

repo_name: diycp/HTML-Sheets-of-Paper


text:
# ecc-calculations

Reference code for performing some ECC calculations directly with ECC operations.

The reference code is for NIST P-256 (secp256r1) curve, but can be relatively easily applied to
other curves.

A useful function performed by this reference code is deriving a public key from
an ECC signature. This is an interesting operation, not commonly supported by
standard libraries.

## Calculations

* **verify_signature_ecc_calcs(public_key, message, signature)** - Verify an ECC
  signature over a message, with the provided public key.
* **public_keys_from_signature(message, signature)** - Derive possible public keys
  that can correctly verify the ECC signature over a message (more than a single
  valid public key may be returned).
* **public_keys_from_multiple_signatures(messages_and_signatures)** - Derive a single
  public key that can correctly verify all the ECC signatures over the messages.

## Used Libraries

**[pycryptodome](https://github.com/Legrandin/pycryptodome/)**,
**[tinyec](https://github.com/alexmgr/tinyec)** and
**[nummaster](https://pypi.org/project/nummaster/)** are used for various primitives.

## License

[Apache License 2.0](LICENSE).

repository: trianglee/ecc-calculations

repo_name: trianglee/ecc-calculations


text:
# The Ten Commandments Of Continuous Delivery

## Abstract

Everyone wants to implement continuous delivery. After all, the benefits are too big to be ignored. Increase the speed of delivery, increase the quality, decrease the costs, free people to dedicate time on what brings value, and so on and so forth. Those improvements are like music to any decision maker. Especially if that person has a business background. If a tech geek can articulate the benefits continuous delivery brings to the table, when he asks a business representative for a budget, the response is almost always "Yes! Do it."

A continuous delivery project will start. Tests will be written. Builds will be scripted. Deployments will be automated. Everything will be tied into an automated pipeline and triggered on every commit. Everyone will enter a state of nirvana as soon as all that is done. There will be a huge inauguration party with a vice president having the honor to be the first one to press the button that will deploy the first release to production. Isn't that a glorious plan everyone should be proud of?

The project starts and, shortly afterward, you hit the first obstacle. But, since you are brave and do not give up that easily, you pass it. Then, not long afterward, another obstacle comes along. And another one after that. And on and on it goes. Half a year later you feel that you are not getting far. You spent your budget. You need to show results even though you cannot see the light at the end of the tunnel. CTO demands results. Business wants value for the investment. You decide to do the only sensible thing and declare that the project is finished.  Continuous delivery joins other failed projects that are declared a big success. Not only that you are doing agile but you also practice CD. Veni, vidi, vici. You joined the club of glorified failures. Well done!

Why did your attempt to implement continuous delivery fail? There cannot be one answer that fits all scenarios. However, some prerequisites and steps should be taken in almost all cases. The chances are that you missed some, if not all, of the commandments that we'll explore in this session.

## Pitch

Why did your attempt to implement continuous delivery fail?

gha_language: HTML


text:
---
title: Christ in Song - 031-040
metadata:
    description: |
        Christ in Song - 031-040
    keywords:  |
        Christ in Song, adventhymnals, advent hymnals, 031-040
    author: Brian Onang'o
---

#### Advent Hymnals
## Christ in Song - 031-040

# Index of Titles
# | Title
-- |-------------
031|[Come, Great Deliverer, Come](/christ-in-song/001-100/031-040/Come,-Great-Deliverer,-Come)
032|[Build on the Rock](/christ-in-song/001-100/031-040/Build-on-the-Rock)
033|[Building for Eternity](/christ-in-song/001-100/031-040/Building-for-Eternity)
034|[The Grand Old Story of Salvation](/christ-in-song/001-100/031-040/The-Grand-Old-Story-of-Salvation)
035|[Knocking, Knocking](/christ-in-song/001-100/031-040/Knocking,-Knocking)
036|[My Name in Mother's Prayer](/christ-in-song/001-100/031-040/My-Name-in-Mother's-Prayer)
037|[Eternity!  Where?](/christ-in-song/001-100/031-040/Eternity!-Where)
038|[The Passover](/christ-in-song/001-100/031-040/The-Passover)
039|[In the Silent Midnight Watches](/christ-in-song/001-100/031-040/In-the-Silent-Midnight-Watches)
040|[Tell Me the Story of Jesus](/christ-in-song/001-100/031-040/Tell-Me-the-Story-of-Jesus)

repository: GospelSounders/adventhymnals

repo_name: GospelSounders/adventhymnals


text:
# find.patch Test

```unison
---
title: test.u
---
hey = "yello"

```

```ucm

  I found and typechecked these definitions in test.u. If you do
  an `add` or `update`, here's how your codebase would change:

    ⍟ These new definitions are ok to `add`:

      hey : Text

```
```ucm
.> add

  ⍟ I've added these definitions:

    hey : Text

```
Update

```unison
---
title: test.u
---
hey = "hello"

```

```ucm

  I found and typechecked these definitions in test.u. If you do
  an `add` or `update`, here's how your codebase would change:

    ⍟ These names already exist. You can `update` them to your
      new definition:

      hey : Text

```
Update

```ucm
.> update

  ⍟ I've updated these names to your new definition:

    hey : Text

.> find.patch

  1. patch

.> view.patch 1

  Edited Terms: 1. hey#m0kuh98ou7 -> 2. hey

  Tip: To remove entries from a patch, use
       delete.term-replacement or delete.type-replacement, as
       appropriate.

```

repository: unisonweb/unison

branch_name: refs/heads/trunk

gha_language: Haskell

repo_name: unisonweb/unison


text:
GlobalADN
=========

Test project from me to get used to Swift and develop best practices

Included are:

1. Unit Tests
2. Separation of UITableViewDataSource and the view controller
3. A light view controller
4. Building UI without Interface Builder
5. Self-sizing table view cells.
6. Parsing of a REST JSON response (in Swift using NSDictionaries and NSArrays)

I tried to think about what feels right in Swift and how a small iOS app in Swift could be structured.

Let me know what you think (on [Twitter](https://twitter.com/dasdom) or [ADN](https://alpha.app.net/dasdom)).

repository: dasdom/GlobalADN

repo_name: dasdom/GlobalADN


text:
# Lesson 1:  [![slides](../_images/slides-clean.png)](slides/june-DSO-bootcamp-week-seven-lesson-one.pdf)[![view](../_images/view-clean.png)](https://speakerdeck.com/devsecops/devsecops-bootcamp-week-7-lesson-1)

## Agenda

```
* Incident Response
* Issues
* Gathering Data
* Forensics Account
* Instances
* ELBs
* Lab 1
```

## Lab #1 [![slides](../_images/lab-clean.png)](labs/LAB-1.md)

```
* Gather Instance Configuration
* Gather IAM Configuration
* Upload Configuration to S3
* Challenge
```

## Resources

* [ec2 Command Line Tools] (http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/command-reference.html)
* [ec2-describe-instances](http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-DescribeInstances.html)

repository: godinezj/bootcamp

repo_name: godinezj/bootcamp


text:
Vagrant Dev Template
====================

A template Vagrant sandbox. Assuming you have Vagrant installed, it will create a small virtual machine sandbox that makes it easy to work on a project, without cluttering up your own dev PC with tons of dependencies that you'll never use for any other purpose. Of course you could use a container system like Docker, but that learning curve is not trivial and ain't nobody got time for that.

Provisioning
------------

Anything you put in the [sandbox-home](sandbox-home/) directory will automatically be copied into the home folder of your new sandbox VM during provisioning. This includes the [provision.sh](sandbox-home/provision.sh) script, which will also be run when the virtual machine is started for the first time. Just edit it to install necessary software, make configuration changes, etc.

The src folder
--------------

The `src` folder is where you do work. It is automatically synchronized with the sandbox's `~/src` folder. You can check out a [Git submodule](https://git-scm.com/book/en/v2/Git-Tools-Submodules) here, or whatever.

The run script
--------------

Right now [run.sh](run.sh) just starts the sandbox VM and provisions it if necessary. You can also edit it to tell the VM to perform some action, like serve a web page or execute a script in [sandbox-home](sandbox-home/).

repository: pcrockett/vagrant-dev-template

repo_name: pcrockett/vagrant-dev-template


text:
# Changes to PostCSS Focus Visible

### 4.0.0 (September 17, 2018)

- Updated: Support for PostCSS v7+
- Updated: Support for Node v6+

### 3.0.0 (April 7, 2018)

- Changed: default functionality to preserve the original rule
- Added: `preserve` option to preserve the original rule using `:focus-visible`

### 2.0.0 (February 17, 2018)

- Changed `:focus-ring` to `:focus-visible` per the specification
- Removed `assignTo` export option

### 1.0.0 (May 22, 2017)

- Initial version

repository: jeffmcfadden/PiThermostat

gha_language: Ruby

repo_name: jeffmcfadden/PiThermostat


text:
# Laravel 5.5 + Angular 4 + AdminLTE

![logo](image.png "Logo")

This is a simple application starter for [Laravel 5.5.x](https://laravel.com) + [Angular 4](https://angular.io/) and [AdminLTE](https://github.com/almasaeed2010/AdminLTE).

The Angular code is based on [Angular Webpack Starter](https://github.com/preboot/angular-webpack)

## Installation

- Clone the repository
- then run `composer install & npm install`

### Development

Run `npm run start` to start a server that'll run on `http://localhost:3000` or `npm run build-dev` to just compile the assets to public/build

### Build

You can also run `npm run build` to use webpack.config.js configuration instead of Laravel Mix.

### Laravel Mix

You can use Laravel Mix by running `npm run dev` or `npm run production`, The output will be published to public/build but it'll be incomplete and won't work with mix() functions in the layout by default.

### Usage

By default the angular code came with index.html which you can use but you can also use the Laravel blade templates as the layout file. Either one works.

If you have any questions please use the Issues tab or submit a pull request. I tried to keep this as simple as possible without all the tests, linting etc... just the basic form of a starter repository to be able to use Angular 4 with Laravel 5.5 as the backend.

[@ilirhushi](http://ilirhushi.me)

### License
This project is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT).


text:
# Sanford::Rabl

Sanford [template engine](https://github.com/redding/sanford) for rendering Rabl templates

## Usage

Register the engine:

```ruby
# in config/services.rb or wherever
require 'sanford'
require 'sanford-rabl'

Sanford.configure do |c|

  c.template_source "/path/to/templates" do |s|
    s.engine 'rabl', Sanford::Rabl::TemplateEngine
  end

end
```

Add `.rabl` to any template files in your template source path.  Sanford will render their content using Rabl when they are rendered.

### Notes

Rabl allows you to specify the template scope.  Templates will be rendered in the scope of the service handler.  Therefore, you can access any service handler attributes directly in the template file.

## Installation

Add this line to your application's Gemfile:

    gem 'sanford-rabl'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install sanford-rabl

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: redding/sanford-rabl

repo_name: redding/sanford-rabl