text:
# Core

Milkdown core is composed mainly by three parts:

-   Markdown Parser
-   Markdown Serializer
-   Prosemirror

---

## Markdown Parser

> The parser can **transform a markdown string into a prosemirror node tree**.

It is mainly used by transforming the default value, and can be used in features like paste markdown strings.

The parser will parse the markdown strings into ast by [remark](https://github.com/remarkjs/remark),
and transform the ast into the prosemirror node.

## Markdown Serializer

> The serializer can **transform a prosemirror node into a markdown string**.

It is mainly used by listeners, and can be used in features like export to file.
The serializer will parse the prosemirror node tree and transform it into markdown ast,
then the ast can be serialized into markdown string.

## Prosemirror

> Prosemirror is **used for render editor**.

When users interact with the editor, they actually interact with the [prosemirror view instance](https://prosemirror.net/docs/guide/#view).

---

So basically,
a milkdown editor works following these steps:

1. Default value is parsed by parser, generates a node.
2. Node generated by step 1 will be used to create a prosemirror instance.
3. When changes are triggered, the listeners will be called and developers can use serializer to get markdown string.

repository: cbbfcd/milkdown

repo_name: cbbfcd/milkdown


text:
# SwiftXPC

This is a Swift binding of the OS X XPC module. It makes it possible to call 95% of the public XPC API
from pure Swift. (The only part of XPC that isn’t exposed currently is the API found in `<xpc/activity.h>`.)

To use this framework, you must be running Xcode 6 beta 4. Clone this repository, add the Xcode project
to your application, and copy `SwiftXPC.framework` into your app’s Frameworks folder.

license: MIT

repository: wjk/SwiftXPC

branch_name: refs/heads/master

extension: md

gha_language: Swift

license_type: permissive

repo_name: wjk/SwiftXPC


text:
Improve two existing working SQLite queries by adding a pivot on a few rows to become columns.
See the excel sheet (Query_As_is_desired_Results) where I show As-is results and the desired results (how the new query result should look like)

1. Execute this query MultiColumns.sql on the MultiColumns.sqlite database
2. Execute this query SeasonalParameter.sql on the Seasonal.sqlite database

Here is the db schema
http://amabdallah.github.io/test2/diagrams/01_WaMDaM_NoCVs.html

https://gist.github.com/waylan/6555316


text:
---
name: Tuvix
rarity: 4
series: voy
memory_alpha:
bigbook_tier: 7
events: 26
in_portal:
date: 01/01/2016
obtained: Fuse
mega: false
published: true
---

"They used to be better" is an easy refrain for older cards, but at least in this case it's better than "They used to be alive." Got eeeem!

Pretty far removed from the voyage and daily shuttle pictures (barring an embarrassment of blue fusion fodder early on), you're essentially welcoming aboard two armfuls of traits with an eye toward collections.

While fusion crew often boast enhanced event prospects (Reunion Spock & Kirk, Indulgent Seven), Neelix has never been a big name for bonuses and even Tuvok has garnered a disrespectfully small number of events. Consider Tuvix an early/mid-game fusion prospect with some nice trait potential, but it's generally better to focus on the influx of pre-fused event reward crew early on.

repository: joshurtree/datacore-website

gha_language: TypeScript

gha_license_id: MIT

repo_name: joshurtree/datacore-website


text:
---
name: Bug report
about: Describe a bug associated with LyricsGenius

---

**Describe the bug**
Write a clear and concise description of what the bug is.

**Expected behavior**
Write a clear and concise description of what you expected to happen.

**To Reproduce**
Describe the steps required to reproduce the behavior.
1. Step one...
2. Step two...

Include the error message associated with the bug.

**Version info**
 - Package version [`import lyricsgenius; print(lyricsgenius.__version__)`]
 - OS: [e.g. macOS, Windows, etc.]

**Additional context**
Add any other context about the problem here.

repository: johnwmillr/LyricsGenius

gha_language: Python

repo_name: johnwmillr/LyricsGenius


text:
# docker-openjabnab
(Fork of [fbricon/openjabnab-docker](https://github.com/fbricon/openjabnab-docker) with some issues fixes)

Image build on DockerHub : https://hub.docker.com/r/antoineaumjaud/docker-openjabnab/

## Updates
TODO after image pulled:
- change [OpenJabNabServers] in config file /var/www/OpenJabNab/server/bin with your domain

## Ports
- port 80:  PHP web site for administraction (shoul be exposed)
- port 8080: Nabaztag server, is used internaly only (call from PHP web site)
- port 5222: (to expose) is use for [XMPP](https://fr.wikipedia.org/wiki/Extensible_Messaging_and_Presence_Protocol)

## URLs
- URL admin access is: http://<my.domain>/ojn_admin/

repository: mfrisby/docker-openjabnab

repo_name: mfrisby/docker-openjabnab


text:
---
title: Vignette Effect
template: usermanual-page.tmpl.html
position: 6
---

In photography and optics, vignetting is a reduction of an image's brightness or saturation at the periphery compared to the image center. You can use it to draw attention to the center of the frame. (from [Wikipedia][1])

Here is an image without the effect:

and the same image with the effect applied:

The built-in vignette effect has the following attributes:

* **Offset**: Controls the offset of the effect.
* **Darkness**: Controls the darkness of the effect.

[1]: http://en.wikipedia.org/wiki/Vignetting


text:
# Go-Docker

## Overview
----------

Wrapper for the docker-compose container written in go.

## Prerequisites
----------------

* [Go](https://golang.org/doc/install) must be installed (having the path set).
* [Docker](https://docs.docker.com/engine/installation/) must be installed
* [Docker-Compose](https://docs.docker.com/compose/install/) must be installed

## Install
----------

* Under Development


text:
## Problem Statement

Today, if many applications want to share dependencies (layers), there isn't
really a good way to do it. For example, if I have two stacker files (or
similar Docker files):

    A:
        from:
            type: docker
            url: docker://centos:latest
        run:
            - yum install openssl git
            - git clone https://example.com/A
            - ./A/install
    B:
        from:
            type: docker
            url: docker://centos:latest
        run:
            - yum install openssl git
            - git clone https://example.com/B
            - ./B/install

A and B both depend on ssl, but there is no real way to share the actual bits
that ssl depends on. There are two reasons to want to share this: 1. save disk
space, 2. know that everything image relying on ssl has all the latest security
fixes.

## Comparison With State of the Art

Today, the state of the art would be two stacker files with the same `yum
install` or `apt-get install` lines. If there is a security update, the
maintainers of A and B both need to re-build their containers in order to
deploy an up to date version.

Enter layer merging. The idea here is that we relax the constraint that a
container should be the *exact* bits it as built with, based on the insight
that most of the time the libraries are not necessarily that important, but the
application level bits are. So we keep the application level stuff bit for bit,
but allow developers to refer to libraries by a semantic name.

Then, with a suitable container runtime, application developers are not needed
to deploy security updates: instead operators just switch out the layer that
ssl points to with a new one, re-deploy the containers, and the containers see
the new versions. Development of such a runtime is left as an exercise for the
reader :)

The hardest part of this is (I think) to socialize the idea of relaxing the
*exact* bit for bit requirement.

## Implementation

The implementation stacker used to have was fairly basic. Given a stacker file with
an apply section:

    app:
        from:
            type: docker
            url: docker://ubuntu:latest
        apply:
            - docker://ssl:latest
            - docker://java:latest
        run: ...

Stacker will first download the base image, which may be made up of more than
one layer. Then, it will iterate through each of the apply entries in order (in
this case, ssl, java), and examine each layer that the tag contains but the
base does not yet contain. For each layer that is examined, it takes each file
in the layer, and compares it with the corresponding file in the base. If the
file "is equal to" the file on disk, it continues on. If the files are not
equal, stacker:

1. tests if the file is text, if not then fail
1. tries to automatically merge what is in the base with what is in the layer,
   if it can't be automatically merged, then fail

As each layer is processed, it is also inserted into the emitted OCI image. The
insight here is that the layer is included in the image. At the end of `apply`
processing, the `run` section is completed as normal, and a layer, including
the diffs from any non-identical files in the `apply` section are completed.

For example, suppose that `ubuntu:latest` contains the layers:

    e05fab2a890d758805e3f67be201e60e838e99bc -> ubuntu:latest
    39ad9e63562e5d70875918ca574d9fe0c6f550ac

And `ssl:latest` has the layers

    64fabd853e4de75a7ea3734d0a994047a1af9dc4 -> ssl:latest
    e05fab2a890d758805e3f67be201e60e838e99bc -> ubuntu:latest
    39ad9e63562e5d70875918ca574d9fe0c6f550ac

And `java:latest` has the layers

    8ab6c5e1cb34a35a35376b6c020cdf301258e428 -> java:latest
    5777ec212fc44052fd0654f808b2c67ac99aa6c3
    e05fab2a890d758805e3f67be201e60e838e99bc -> ubuntu:latest
    39ad9e63562e5d70875918ca574d9fe0c6f550ac

Suppose that the `ssl:latest` layer has no conflicts, but the `java:latest`
layer does conflict with the base. The resulting layer output will be:

    c34553482dda4a28dd22c084b2644f6cff25b2f5 -> diff from java:latest + run
    8ab6c5e1cb34a35a35376b6c020cdf301258e428 -> java:latest, included verbatim
    5777ec212fc44052fd0654f808b2c67ac99aa6c3
    64fabd853e4de75a7ea3734d0a994047a1af9dc4 -> ssl:latest, included verbatim
    e05fab2a890d758805e3f67be201e60e838e99bc -> ubuntu:latest
    39ad9e63562e5d70875918ca574d9fe0c6f550ac

## Retirement

This implementation never saw any real world use, and was standing in the way
of other innovations, so ultimately it was removed.

Additionally, it had several problems relating merging binary package databases
(rpm), or when two different layers would modify the ld.so.cache. Solving these
problems remain future work :)

repository: andaaron/stacker

repo_name: andaaron/stacker


text:
# Eladia saccula (E. Dale) G. Sm., 1961 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Trans. Br. mycol. Soc. 44: 47 (1961)

#### Original name
Penicillium sacculum E. Dale, 1927

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
aliases:
- ../../set-up/install-agent-linux/
- ../set-up/install-agent-linux/
canonical: https://grafana.com/docs/agent/latest/static/set-up/install/install-agent-linux/
menuTitle: Linux
title: Install Grafana Agent in static mode on Linux
weight: 400
---

# Install static mode on Linux

You can install Grafana Agent in static mode on Linux.

## Install on Debian or Ubuntu

To install Grafana Agent in static mode on Debian or Ubuntu, run the following commands in a terminal window.

1. Import the GPG key and add the Grafana package repository:

   ```shell
   sudo mkdir -p /etc/apt/keyrings/
   wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null
   echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
   ```

1. Update the repositories:

   ```shell
   sudo apt-get update
   ```

1. Install Grafana Agent:

   ```shell
   sudo apt-get install grafana-agent
   ```

### Uninstall on Debian or Ubuntu

To uninstall Grafana Agent on Debian or Ubuntu, run the following commands in a terminal window.

1. Stop the systemd service for Grafana Agent:

   ```shell
   sudo systemctl stop grafana-agent
   ```

1. Uninstall Grafana Agent:

   ```shell
   sudo apt-get remove grafana-agent
   ```

1. Optional: Remove the Grafana repository:

   ```shell
   sudo rm -i /etc/apt/sources.list.d/grafana.list
   ```

## Install on RHEL or Fedora

To install Grafana Agent in static mode on RHEL or Fedora, run the following commands in a terminal window.

1. Import the GPG key:

   ```shell
   wget -q -O gpg.key https://rpm.grafana.com/gpg.key
   sudo rpm --import gpg.key
   ```

1. Create `/etc/yum.repos.d/grafana.repo` with the following content:

   ```shell
   sudo nano /etc/yum.repos.d/grafana.repo
   [grafana]
   name=grafana
   baseurl=https://rpm.grafana.com
   repo_gpgcheck=1
   enabled=1
   gpgcheck=1
   gpgkey=https://rpm.grafana.com/gpg.key
   sslverify=1
   sslcacert=/etc/pki/tls/certs/ca-bundle.crt
   ```

1. Optional: Verify the Grafana repository configuration:

   ```shell
   cat /etc/yum.repos.d/grafana.repo
   ```

1. Install Grafana Agent:

   ```shell
   sudo dnf install grafana-agent
   ```

### Uninstall on RHEL or Fedora

To uninstall Grafana Agent on RHEL or Fedora, run the following commands in a terminal window:

1. Stop the systemd service for Grafana Agent:

   ```shell
   sudo systemctl stop grafana-agent
   ```

1. Uninstall Grafana Agent:

   ```shell
   sudo dnf remove grafana-agent
   ```

1. Optional: Remove the Grafana repository:

   ```shell
   sudo rm -i /etc/yum.repos.d/rpm.grafana.repo
   ```

## Install on SUSE or openSUSE

To install Grafana Agent in static mode on SUSE or openSUSE, run the following commands in a terminal window.

1. Import the GPG key and add the Grafana package repository:

   ```shell
   wget -q -O gpg.key https://apt.grafana.com/gpg.key
   sudo rpm --import gpg.key
   sudo zypper addrepo https://rpm.grafana.com grafana
   ```

1. Update the repositories:

   ```shell
   sudo zypper update
   ```

1. Install Grafana Agent:

   ```shell
   sudo zypper install grafana-agent
   ```

### Uninstall on SUSE or openSUSE

To uninstall Grafana Agent on SUSE or openSUSE, run the following commands in a terminal:

1. Stop the systemd service for Grafana Agent:

   ```shell
   sudo systemctl stop grafana-agent
   ````

1. Uninstall Grafana Agent:

   ```shell
   sudo zypper remove grafana-agent
   ```

1. Optional: Remove the Grafana repository:

   ```shell
   sudo zypper removerepo grafana
   ```

## Operation guide

The Grafana Agent is configured as a [systemd](https://systemd.io/) service.

### Start the Agent

To run Grafana Agent, run the following in a terminal:

   ```shell
   sudo systemctl start grafana-agent
   ```

To check the status of Grafana Agent, run the following command in a terminal:

   ```shell
   sudo systemctl status grafana-agent
   ```

### Run Grafana Agent on startup

To automatically run Grafana Agent when the system starts, run the following command in a terminal:

   ```shell
   sudo systemctl enable grafana-agent.service
   ```

### Configuring Grafana Agent

To configure Grafana Agent when installed on Linux, perform the following steps:

1. Edit the default configuration file at `/etc/grafana-agent.yaml`.

1. Run the following command in a terminal to reload the configuration file:

   ```shell
   sudo systemctl reload grafana-agent
   ```

### View Grafana Agent logs

Logs of Grafana Agent can be found by running the following command in a terminal:

   ```shell
   sudo journalctl -u grafana-agent
   ```

## Next steps

- [Start Grafana Agent][start]
- [Configure Grafana Agent][configure]

{{% docs/reference %}}
[start]: "/docs/agent/ -> /docs/agent/<AGENT VERSION>/static/set-up/start-agent"
[start]: "/docs/grafana-cloud/ -> ../start-agent"
[configure]: "/docs/agent/ -> /docs/agent/<AGENT VERSION>/static/configuration/create-config-file"
[configure]: "/docs/grafana-cloud/ -> ../../configuration/create-config-file"
{{% /docs/reference %}}

repository: grafana/agent

branch_name: refs/heads/main

gha_language: Go

repo_name: grafana/agent


text:
---
hrs_structure:
  division: '2'
  volume: '8'
  title: '22'
  chapter: '412'
  section: '412:12-105'
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0412-0012-0105
    parent: HRS0412
    name: '412:12-105 Authority of out-of-state banks to establish a de'
weight: 24940
title: Authority of out-of-state banks to establish a de
full_title: '412:12-105 Authority of out-of-state banks to establish a de'
---
**§412:12-105 Authority of out-of-state banks to establish a de novo interstate branch or acquire an interstate branch.** (a) An out-of-state bank that does not operate a branch in this State and that meets the requirements of this article may establish and operate a branch in this State.

(b) An out-of-state bank that does not operate a branch in this State and that meets the requirements of this article may establish and operate a branch in this State through the acquisition of a branch.

(c) An out-of-state bank desiring to establish and operate a branch or to acquire and operate a branch in this State pursuant to this section shall provide to the commissioner written notice of the proposed transaction not later than the date on which the bank applies to the responsible federal bank supervisory agency for approval to establish or acquire the branch. The filing of the notice shall be accompanied by a filing fee of $9,000 or a greater amount as the commissioner may establish by rule pursuant to chapter 91\. The filing fee shall be nonrefundable.

(d) No branch of an out-of-state bank may be established or acquired in this State under this section, unless:

(1) The out-of-state bank confirms in writing to the commissioner that as long as it maintains a branch in this State, it shall comply with all applicable laws of this State;

(2) The applicant provides to the commissioner satisfactory evidence of compliance with the applicable requirements of chapter 414 relating to foreign corporations; and

(3) The commissioner, acting within thirty days after receiving notice of an application under subsection (c), certifies to the responsible federal bank supervisory agency that the requirements of this article have been met. [L 1996, c 155, pt of §1; am L 1999, c 283, §2; am L 2002, c 40, §35]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# step-slack [![Build status](https://img.shields.io/wercker/ci/5541cd77771355eb4000583f.svg "Build status")](https://app.wercker.com/project/bykey/be0b458e85f974c293cf97dea2354a7c)

A slack notifier written in `bash` and `curl`. Make sure you create a Slack
webhook first (see the Slack integrations page to set one up).

# Options

- `url` Slack webhook url
- `username` (optional) Message username override
- `icon_url` (optional) Message icon override
- `notify_on` (optional) If set to `failed`, it will only notify on failed builds or deploys.

# Example

```yaml
build:
    after-steps:
        - turistforeningen/slack-notifier:
            url: $SLACK_WEBHOOK_URL
```

The `url` parameter is the [slack
webhook](https://api.slack.com/incoming-webhooks) that wercker should post to.
You can create an *incoming webhook* on your slack integration page.  This url
is then exposed as an environment variable (in this case `$SLACK_WEBHOOK_URL`)
that you create through the wercker web interface as *deploy pipeline variable*.

# License

The MIT License (MIT)

# Changelog

## 2.0.0

- Fail/Pass username
- Fail/Pass icon

## 1.0.0

- Initial release

repository: Turistforeningen/step-slack

repo_name: Turistforeningen/step-slack


text:
---

copyright:
 years: 2015, 2016

---

# Registering devices

{: #cordova_register}

To register a device with the Push Notification Service, call the register method.

Copy and paste the following code snippet into your Cordova application to register a device.

```
	var success = function(message) { console.log("Success: " + message); };
	var failure = function(message) { console.log("Error: " + message); };
	MFPPush.registerDevice({}, success, failure);
```

## Android
{: #cordova_register_android}
Android does not use of the settings parameter. If you are only building an Android app, pass an empty object; for example:

```
	MFPPush.registerDevice({}, success, failure);
	MFPPush.unregisterDevice(success, failure);
```

##	iOS
{: #cordova_register_ios}
If you want to customize the alert, badge, and sound properties, add the following JavaScript code snippet to the web part of your Cordova application.

```
	var settings = {
	   ios: {
	       alert: true,
	       badge: true,
	       sound: true
	   }
	}
	MFPPush.registerDevice(settings, success, failure);
```

##JavaScript
{: #cordova_register_js}

```
MFPPush.registerDevice({}, success, failure);
```

You can access the contents of the success response parameter in Javascript using JSON.parse:
**var token = JSON.parse(response).token**

Available keys are as follows: `token`, `userId`, and `deviceId`.

The following JavaScript code snippet shows how to initialize your Bluemix Mobile Services client SDK, register a device with the Push Notification Service, and listen to push notifications. You put this code in your Javascript file.

```
//Register device token with Bluemix Push Notification Service
funcapplication(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData){
  CDVMFPPush.sharedInstance().didRegisterForRemoteNotifications(deviceToken)
}
```

```
//Handle error when failed to register device token with APNs
funcapplication(application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: NSErrorPointer){
CDVMFPPush.sharedInstance().didFailToRegisterForRemoteNotifications(error)
}
```

within the **onDeviceReady: function()**.

```
onDeviceReady: function() {
     app.receivedEvent('deviceready');
     BMSClient.initialize("https://http://myroute_mybluemix.net","my_appGuid");
     var success = function(message) { console.log("Success: " + message); };
     var failure = function(message) { console.log("Error: " + message); };
     var settings = {
         ios: {
             alert: true,
             badge: true,
             sound: true
         }
     };
     MFPPush.registerDevice(settings, success, failure);
     var notification = function(notif){
         alert (notif.message);
     };
     MFPPush.registerNotificationsCallback(notification);

 }
```

## Objective-C
{: #cordova_register_objective}
Add the following Objective-C code snippet to your application delegate class

```
	// Register the device token with Bluemix Push Notification Service
	- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
	  [[CDVMFPPush sharedInstance] didRegisterForRemoteNotifications:deviceToken];
	}
	// Handle error when failed to register device token with APNs
	- (void)application:(UIApplication*)application didFailToRegisterForRemoteNotificationsWithError:(NSError*)error {
	   [[CDVMFPPush sharedInstance] didFailToRegisterForRemoteNotificationsWithError:error];
	}
```

##Swift
{: #cordova_register_swift}
Add the following Swift code snippet to your application delegate class.

```
funcapplication(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData){
   CDVMFPPush.sharedInstance().didRegisterForRemoteNotifications(deviceToken)
}
// Handle error when failed to register device token with APNs
funcapplication(application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: NSErrorPointer){
   CDVMFPPush.sharedInstance().didFailToRegisterForRemoteNotifications(error)
}
```

##Next Steps
{: #cordova_register_next}

1. Build your project and then run your project by using the following commands:

	* Android - **cordova build android** and then **cordova run android**

	* iOS - **cordova build ios** and then **cordova run ios**
1. [Receiving push notifications on devices](t_cordova_receive.html).

repository: csantanapr/docs

repo_name: csantanapr/docs


text:
# Kubernator

# DEPRECATED
## In favor of [our new vscode extension](https://marketplace.visualstudio.com/items?itemName=smpio.kubernator-vscode)

[![Docker Build Status](https://img.shields.io/docker/build/smpio/kubernator.svg)](https://hub.docker.com/r/smpio/kubernator/)
[![GitHub last commit](https://img.shields.io/github/last-commit/smpio/kubernator.svg)](https://github.com/smpio/kubernator)
[![GitHub commit activity the past week, 4 weeks, year](https://img.shields.io/github/commit-activity/y/smpio/kubernator.svg)](https://github.com/smpio/kubernator)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/smpio/kubernator.svg)](https://github.com/smpio/kubernator)
[![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/smpio/kubernator.svg)](https://github.com/smpio/kubernator)
[![GitHub license](https://img.shields.io/github/license/smpio/kubernator.svg)](https://github.com/smpio/kubernator/blob/master/LICENSE)

`Kubernator` is an alternative [Kubernetes](https://kubernetes.io) UI. In contrast to high-level [Kubernetes Dashboard](https://github.com/kubernetes/dashboard), it provides low-level control and clean view on **all** objects in a cluster with the ability to create new ones, edit and resolve conflicts. As an entirely client-side app (like `kubectl`), it doesn't require any backend except Kubernetes API server itself, and also respects cluster's access control.

## TL;DR

```sh
kubectl create ns kubernator
kubectl -n kubernator run --image=smpio/kubernator --port=80 kubernator
kubectl -n kubernator expose deploy kubernator
kubectl proxy
```

Then open [service proxy URL](http://localhost:8001/api/v1/namespaces/kubernator/services/kubernator/proxy/) in your browser.

Note that **exposing it as ingress** won't work, because the page should be on the same domain as API server. This is totally client-side app. `kubectl proxy` **should be** running.

![Catalog: Overview](screenshots/catalog-overview.png)

## Table of Contents

- [Features](#features)
  - [Catalog](#catalog)
    - [Navigation Tree](#navigation-tree)
    - [Extensive Caching](#extensive-caching)
    - [Multiple API Versions](#multiple-api-versions)
    - [Tabs](#tabs)
    - [Copying Objects](#copying-objects)
    - [Actions Bar](#actions-bar)
    - [Keyboard Shortcuts](#keyboard-shortcuts)
    - [Diff Editor](#diff-editor)
  - [RBAC Viewer](#rbac-viewer)
    - [Controls](#controls)
    - [Graph](#graph)
  - [Notifications](#notifications)
- [Getting Started](#getting-started)
  - [Install on Cluster](#install-on-cluster-recommended)
  - [Run in Docker Locally](#run-in-docker-locally)
  - [Build and Run Locally](#build-and-run-locally)
  - [Desktop App](#desktop-app)
- [Support](#support)

## Features

### Catalog

Catalog offers an intuitive interface for managing Kubernetes objects (like `Deployment`, `Service` and everything else). Objects can be created, compared, modified and removed using a powerful diff editor.

#### Navigation Tree

Navigation tree shows objects' kinds, grouped by namespaces, and objects themselves. All API groups are fetched, which yields a list of versions and endpoints for every group. Then for all groups and versions `Kubernator` loads resources list, and then ― list of objects for every known resource. To show the tree, objects are grouped by their namespaces. Navigation has its own actions bar, which currently consists from one action ― reload namespaces.

![Catalog: Navigation Tree](screenshots/catalog-navigation-tree.gif)

#### Extensive Caching

`Kubernator` fires a lot of API calls, that's why it actively caches their responses in browser's local storage to boost loading times in subsequent uses, e.g. API groups and Swagger schemas are reloaded only when cluster is upgraded. Resources are reloaded every time the corresponding kind or namespace is being opened. And objects are reloaded again when opened in the editor.

#### Multiple API Versions

Every group fetches its resources using all API versions, not only the preferred one, and then merges given resources into one list considering versions priority. It means we can access objects through different API versions. Moreover, when a new object is created, an API endpoint would be choosed automatically based on the value of `apiVersion` field in its description.

![Catalog: Multiple API Versions](screenshots/catalog-multiple-api-versions.gif)

#### Tabs

Tab names reflect current object's location in the navigation tree (object.namespace → object.kind → object). New objects have green tab color, modified and not submitted objects ― red tab color. Local modifications are saved even if the tab was closed and reopened again.

![Catalog: Tabs](screenshots/catalog-tabs.gif)

#### Copying Objects

When object is being copied, all unnecessary and read-only fields are automatically stripped as described in the corresponding Swagger scheme.

![Catalog: Copying Objects](screenshots/catalog-copying-objects.gif)

#### Actions Bar

Available actions: open a new tab copying current object; close all tabs; reload, save or delete current object; switch currently active tab to the left/right neighbour.

![Catalog: Actions Bar](screenshots/catalog-actions-bar.gif)

#### Keyboard Shortcuts

Most frequent actions have associated keyboard shortcuts.

![Catalog: Keyboard Shortcuts](screenshots/catalog-keyboard-shortcuts.gif)

#### Diff Editor

Diff editor is based on the powerful `Monaco Editor`. Cursor position, scroll position and not applied updates are saved automatically for every open tab.

![Catalog: Diff Editor](screenshots/catalog-diff-editor.gif)

### RBAC Viewer

RBAC viewer shows `Roles`, `ClusterRoles`, `RoleBindings`, `ClusterRoleBindings` and relationships between them in a visually intuitive way.

#### Controls

Simple controls pane allows to show/hide a legend, isolated nodes and extended names.

![RBAC: Overview](screenshots/rbac-overview.png)

#### Graph

Graph area (built with the awesome `d3` library) shows an interactive force graph of linked nodes. The graph can be paned, dragged and zoomed. Nodes are draggable too, and links also show some additional information when hovered.

![RBAC: Graph](screenshots/rbac-graph.gif)

### Notifications

Every error and warning shows itself in a floating message on the right top side of the window. Errors are red and don't vanish automatically as warnings do. An example of concurrent edits of the same object:

![Notifications: Overview](screenshots/notifications-overview.gif)

## Getting started

There are many ways to run `Kubernator`:

### Install on cluster (recommended)

After installation you will have access to Kubernator just by running `kubectl proxy`.  To install, run the following commands:

```sh
kubectl create ns kubernator
kubectl -n kubernator run --image=smpio/kubernator --port=80 kubernator
kubectl -n kubernator expose deploy kubernator
kubectl proxy
```

Then open [service proxy URL](http://localhost:8001/api/v1/namespaces/kubernator/services/kubernator/proxy/) in your browser.

Note that **exposing it as ingress** won't work, because the page should be on the same domain as API server. `kubectl proxy` **should be** running.

### Run in docker locally

1. Exec `docker run -d --name=kubernator -p 3000:80 smpio/kubernator`

2. Run `kubectl proxy`.

3. Open [http://localhost:3000/](http://localhost:3000/) in your browser.

### Build and run locally

1. Install and [set up](https://kubernetes.io/docs/tasks/tools/install-kubectl/) `kubectl`

2. Clone and build `Kubernator`:

    ```sh
    yarn install && yarn build
    ```

3. Run Kubernetes API server:

    ```sh
    kubectl proxy
    ```
4. Update `proxy` value in `package.json` according to the previous command's output.

5. Run `Kubernator`:

    ```sh
    yarn start
    ```

### Desktop app

Coming soon.

## Support

Please [open an issue](https://github.com/smpio/kubernator/issues/new) for support.

Please contribute using [Github Flow](https://guides.github.com/introduction/flow/). Create a branch, add commits, and [open a pull request](https://github.com/smpio/kubernator/compare/).

MIT License

repository: smpio/kubernator

branch_name: refs/heads/dev

gha_language: JavaScript

repo_name: smpio/kubernator


text:
rust-url
========

[![Travis build Status](https://travis-ci.com/servo/rust-url.svg?branch=master)](https://travis-ci.com/servo/rust-url) [![Appveyor build status](https://ci.appveyor.com/api/projects/status/ulkqx2xcemyod6xa?svg=true)](https://ci.appveyor.com/project/Manishearth/rust-url)

URL library for Rust, based on the [URL Standard](https://url.spec.whatwg.org/).

[Documentation](https://docs.rs/url/)

Please see [UPGRADING.md](https://github.com/servo/rust-url/blob/master/UPGRADING.md) if you are upgrading from 0.x to 1.x.

repository: mesalock-linux/crates-sgx

repo_name: mesalock-linux/crates-sgx


text:
MongoDB Driver for Lua
======================

[lua-mongo] is a binding to the [MongoDB C Driver] for Lua.

* Unified API for MongoDB commands, CRUD operations and GridFS in the [MongoDB C Driver].

* Support for custom data transformation handlers when converting to/from BSON documents.

* Transparent conversion from Lua/JSON to BSON for convenience.

* Automatic conversion of Lua numbers to/from BSON Int32, Int64 and Double types depending on their
  capacity without precision loss (when Lua allows it). Manual conversion is also available.

Dependencies
------------

+ lua >= 5.1 (or luajit)
+ libmongoc >= 1.9

Building and installing with LuaRocks
-------------------------------------

To build and install, run:

    luarocks make

To install the latest release using [luarocks.org], run:

    luarocks install lua-mongo

Building and installing with CMake
----------------------------------

To build and install, run:

    cmake .
    make
    make install

To build against a specific Lua version, set the `USE_LUA_VERSION` variable. For example:

    cmake -D USE_LUA_VERSION=5.1 .

or for LuaJIT:

    cmake -D USE_LUA_VERSION=jit .

To build in a separate directory, replace `.` with a path to the source.

To check your build, run:

    make test

A local MongoDB server at `mongodb://<IP_ADDRESS>` will be used for testing by default. Test settings
can be configured in `test/test.lua`.

Getting started
---------------

Preparing the playground:

```Lua
local mongo = require 'mongo'
local client = mongo.Client 'mongodb://<IP_ADDRESS>'
local collection = client:getCollection('lua-mongo-test', 'test')
collection:drop() -- Clear collection

-- Common variables
local id = mongo.ObjectID()
local query1 = mongo.BSON '{ "age" : { "$gt" : 25 } }'
local query2 = mongo.BSON { _id = id }
```

Basic features and operations:

```Lua
-- Store document
collection:insert { _id = id, name = 'John Smith', age = 50 }

-- Fetch document
local document = collection:findOne(query1):value()
print(document.name)

-- Iterate in a for-loop
for document in collection:find(query1):iterator() do
    print(document.name)
end

-- Implicit Lua/JSON to BSON conversion where BSON is required
collection:insert { integer = 123 }
collection:insert '{ "string" : "abc" }'

-- Use options in queries
print(collection:count({}, { skip = 1, limit = 2 }))

-- Access to BSON where needed
local bson = collection:findOne(query1)
print(bson) -- BSON is converted to JSON using tostring()

-- Explicit BSON to Lua conversion
local value = bson:value()
print(value.name)

-- Transparently include BSON documents in other documents
collection:update(query2, { age = 60, backup = bson }) -- Update document
collection:remove(query2) -- Remove document
```

Bulk write operations can be used to execute multiple insert, update, replace and remove operations
together. Executing write operations in batches reduces the number of network round trips increasing
write throughput.

```Lua
local bulk = collection:createBulkOperation()

-- Multiple insertions
bulk:insert { a = 1 }
bulk:insert { b = 2 }
bulk:insert { c = 3 }

-- Multiple modifications
bulk:replaceOne({ a = 1 }, { b = 1 })
bulk:updateMany('{}', '{ "$inc" : { "b" : 2 } }')
bulk:removeOne { c = 3 }

-- Execute all the queued operations
bulk:execute()
```

The use of `__toBSON` metamethods and BSON handlers gives full control over how Lua values are
represented in BSON documents and vice versa. In particular, this API facilitates support for
Lua classes (tables with metatables) on their way to and/or from MongoDB.

```Lua
local TestClass = {} -- Class metatable

local function TestObject(id, name) -- Constructor
    local object = {
        id = id,
        name = name,
    }
    return setmetatable(object, TestClass)
end

function TestClass:__tostring() -- Method
    return tostring(self.id) .. ' --> ' .. self.name
end

function TestClass:__toBSON() -- Called when object is serialized into BSON
    return {
        _id = self.id,
        binary = mongo.Binary(self.name), -- Store 'name' as BSON Binary for example
    }
end

-- A root '__toBSON' metamethod may return a table or BSON document.
-- A nested '__toBSON' metamethod may return a value, BSON type or BSON document.

-- BSON handler
local function handler(document)
    local id = document._id
    local name = document.binary:unpack() -- Restore 'name' from BSON Binary
    return TestObject(id, name)
end

-- Anything callable can serve as a BSON handler. For instance, it can be a table or userdata
-- with a '__call' metamethod.

-- Note that the same handler will be called for each nested document. Thus, the handler should
-- be able to differentiate documents based on some internal criteria.

local object = TestObject(id, 'John Smith')
print(object)

-- Explicit BSON <-> Lua conversion
local bson = mongo.BSON(object)
local object = bson:value(handler)
print(object)

-- Store object
collection:insert(object)

-- Restore object
local object = collection:findOne(query2):value(handler)
print(object)

-- Iterate objects in a for-loop
for object in collection:find(query2):iterator(handler) do
    print(object)
end
```

Check out the [API Reference] for more information.

See also the [MongoDB Manual] for detailed information about MongoDB commands and CRUD operations.

[lua-mongo]: https://github.com/neoxic/lua-mongo
[luarocks.org]: https://luarocks.org
[MongoDB C Driver]: http://mongoc.org
[MongoDB Manual]: https://docs.mongodb.com/manual/
[API Reference]: doc/main.md

repository: qipa/lua-mongo

repo_name: qipa/lua-mongo


text:
---
title: Intel Sse41 Intrinsics
url: /doc/api/intel/sse41/
---

In order to use the functions provided by this module, you need to import this module:

```kalk
>>> import HardwareIntrinsics
```

{{NOTE do}}
These intrinsic functions are only available if your CPU supports `Sse41` features.

{{end}}

## mm_blend_epi16

`mm_blend_epi16`

Blend packed 16-bit integers from "a" and "b" using control mask "imm8", and store the results in "dst".

__m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8)
PBLENDW xmm, xmm/m128 imm8

## mm_blend_pd

`mm_blend_pd`

Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".

__m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8)
BLENDPD xmm, xmm/m128, imm8

## mm_blend_ps

`mm_blend_ps`

Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using control mask "imm8", and store the results in "dst".

__m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8)
BLENDPS xmm, xmm/m128, imm8

## mm_blendv_epi8

`mm_blendv_epi8`

Blend packed 8-bit integers from "a" and "b" using "mask", and store the results in "dst".

__m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask)
PBLENDVB xmm, xmm/m128, xmm

## mm_blendv_pd

`mm_blendv_pd`

Blend packed double-precision (64-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".

__m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask)
BLENDVPD xmm, xmm/m128, xmm0

## mm_blendv_ps

`mm_blendv_ps`

Blend packed single-precision (32-bit) floating-point elements from "a" and "b" using "mask", and store the results in "dst".

__m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask)
BLENDVPS xmm, xmm/m128, xmm0

## mm_ceil_pd

`mm_ceil_pd`

Round the packed double-precision (64-bit) floating-point elements in "a" up to an integer value, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_ceil_pd (__m128d a)
ROUNDPD xmm, xmm/m128, imm8(10)

## mm_ceil_ps

`mm_ceil_ps`

Round the packed single-precision (32-bit) floating-point elements in "a" up to an integer value, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_ceil_ps (__m128 a)
ROUNDPS xmm, xmm/m128, imm8(10)

## mm_ceil_sd

`mm_ceil_sd`

Round the lower double-precision (64-bit) floating-point element in "b" up to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_ceil_sd (__m128d a, __m128d b)
ROUNDSD xmm, xmm/m128, imm8(10)

## mm_ceil_sd1

`mm_ceil_sd1`

Round the lower double-precision (64-bit) floating-point element in "b" up to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_ceil_sd (__m128d a)
ROUNDSD xmm, xmm/m128, imm8(10)

## mm_ceil_ss

`mm_ceil_ss`

Round the lower single-precision (32-bit) floating-point element in "b" up to an integer value, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_ceil_ss (__m128 a, __m128 b)
ROUNDSS xmm, xmm/m128, imm8(10)

## mm_cmpeq_epi64

`mm_cmpeq_epi64`

Compare packed 64-bit integers in "a" and "b" for equality, and store the results in "dst".

__m128i _mm_cmpeq_epi64 (__m128i a, __m128i b)
PCMPEQQ xmm, xmm/m128

## mm_cvtepi16_epi32

`mm_cvtepi16_epi32`

Sign extend packed 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".

__m128i _mm_cvtepi16_epi32 (__m128i a)
PMOVSXWD xmm, xmm/m64

## mm_cvtepi16_epi64

`mm_cvtepi16_epi64`

Sign extend packed 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepi16_epi64 (__m128i a)
PMOVSXWQ xmm, xmm/m32

## mm_cvtepi32_epi64

`mm_cvtepi32_epi64`

Sign extend packed 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepi32_epi64 (__m128i a)
PMOVSXDQ xmm, xmm/m64

## mm_cvtepi8_epi16

`mm_cvtepi8_epi16`

Sign extend packed 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".

__m128i _mm_cvtepi8_epi16 (__m128i a)
PMOVSXBW xmm, xmm/m64

## mm_cvtepi8_epi32

`mm_cvtepi8_epi32`

Sign extend packed 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".

__m128i _mm_cvtepi8_epi32 (__m128i a)
PMOVSXBD xmm, xmm/m32

## mm_cvtepi8_epi64

`mm_cvtepi8_epi64`

Sign extend packed 8-bit integers in the low 8 bytes of "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepi8_epi64 (__m128i a)
PMOVSXBQ xmm, xmm/m16

## mm_cvtepu16_epi32

`mm_cvtepu16_epi32`

Zero extend packed unsigned 16-bit integers in "a" to packed 32-bit integers, and store the results in "dst".

__m128i _mm_cvtepu16_epi32 (__m128i a)
PMOVZXWD xmm, xmm/m64

## mm_cvtepu16_epi64

`mm_cvtepu16_epi64`

Zero extend packed unsigned 16-bit integers in "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepu16_epi64 (__m128i a)
PMOVZXWQ xmm, xmm/m32

## mm_cvtepu32_epi64

`mm_cvtepu32_epi64`

Zero extend packed unsigned 32-bit integers in "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepu32_epi64 (__m128i a)
PMOVZXDQ xmm, xmm/m64

## mm_cvtepu8_epi16

`mm_cvtepu8_epi16`

Zero extend packed unsigned 8-bit integers in "a" to packed 16-bit integers, and store the results in "dst".

__m128i _mm_cvtepu8_epi16 (__m128i a)
PMOVZXBW xmm, xmm/m64

## mm_cvtepu8_epi32

`mm_cvtepu8_epi32`

Zero extend packed unsigned 8-bit integers in "a" to packed 32-bit integers, and store the results in "dst".

__m128i _mm_cvtepu8_epi32 (__m128i a)
PMOVZXBD xmm, xmm/m32

## mm_cvtepu8_epi64

`mm_cvtepu8_epi64`

Zero extend packed unsigned 8-bit integers in the low 8 byte sof "a" to packed 64-bit integers, and store the results in "dst".

__m128i _mm_cvtepu8_epi64 (__m128i a)
PMOVZXBQ xmm, xmm/m16

## mm_dp_pd

`mm_dp_pd`

Conditionally multiply the packed double-precision (64-bit) floating-point elements in "a" and "b" using the high 4 bits in "imm8", sum the four products, and conditionally store the sum in "dst" using the low 4 bits of "imm8".

__m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8)
DPPD xmm, xmm/m128, imm8

## mm_dp_ps

`mm_dp_ps`

Conditionally multiply the packed single-precision (32-bit) floating-point elements in "a" and "b" using the high 4 bits in "imm8", sum the four products, and conditionally store the sum in "dst" using the low 4 bits of "imm8".

__m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8)
DPPS xmm, xmm/m128, imm8

## mm_extract_epi32

`mm_extract_epi32`

Extract a 32-bit integer from "a", selected with "imm8", and store the result in "dst".

int _mm_extract_epi32 (__m128i a, const int imm8)
PEXTRD reg/m32, xmm, imm8

## mm_extract_epi8

`mm_extract_epi8`

Extract an 8-bit integer from "a", selected with "imm8", and store the result in the lower element of "dst".

int _mm_extract_epi8 (__m128i a, const int imm8)
PEXTRB reg/m8, xmm, imm8

## mm_extract_ps

`mm_extract_ps`

Extract a single-precision (32-bit) floating-point element from "a", selected with "imm8", and store the result in "dst".

int _mm_extract_ps (__m128 a, const int imm8)
EXTRACTPS xmm, xmm/m32, imm8

## mm_floor_pd

`mm_floor_pd`

Round the packed double-precision (64-bit) floating-point elements in "a" down to an integer value, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_floor_pd (__m128d a)
ROUNDPD xmm, xmm/m128, imm8(9)

## mm_floor_ps

`mm_floor_ps`

Round the packed single-precision (32-bit) floating-point elements in "a" down to an integer value, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_floor_ps (__m128 a)
ROUNDPS xmm, xmm/m128, imm8(9)

## mm_floor_sd

`mm_floor_sd`

Round the lower double-precision (64-bit) floating-point element in "b" down to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_floor_sd (__m128d a, __m128d b)
ROUNDSD xmm, xmm/m128, imm8(9)

## mm_floor_sd1

`mm_floor_sd1`

Round the lower double-precision (64-bit) floating-point element in "b" down to an integer value, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_floor_sd (__m128d a)
ROUNDSD xmm, xmm/m128, imm8(9)

## mm_floor_ss

`mm_floor_ss`

Round the lower single-precision (32-bit) floating-point element in "b" down to an integer value, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_floor_ss (__m128 a, __m128 b)
ROUNDSS xmm, xmm/m128, imm8(9)

## mm_insert_epi32

`mm_insert_epi32`

Copy "a" to "dst", and insert the 32-bit integer "i" into "dst" at the location specified by "imm8".

__m128i _mm_insert_epi32 (__m128i a, int i, const int imm8)
PINSRD xmm, reg/m32, imm8

## mm_insert_epi8

`mm_insert_epi8`

Copy "a" to "dst", and insert the lower 8-bit integer from "i" into "dst" at the location specified by "imm8".

__m128i _mm_insert_epi8 (__m128i a, int i, const int imm8)
PINSRB xmm, reg/m8, imm8

## mm_insert_ps

`mm_insert_ps`

Copy "a" to "tmp", then insert a single-precision (32-bit) floating-point element from "b" into "tmp" using the control in "imm8". Store "tmp" to "dst" using the mask in "imm8" (elements are zeroed out when the corresponding bit is set).

__m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8)
INSERTPS xmm, xmm/m32, imm8

## mm_max_epi32

`mm_max_epi32`

Compare packed 32-bit integers in "a" and "b", and store packed maximum values in "dst".

__m128i _mm_max_epi32 (__m128i a, __m128i b)
PMAXSD xmm, xmm/m128

## mm_max_epi8

`mm_max_epi8`

Compare packed 8-bit integers in "a" and "b", and store packed maximum values in "dst".

__m128i _mm_max_epi8 (__m128i a, __m128i b)
PMAXSB xmm, xmm/m128

## mm_max_epu16

`mm_max_epu16`

Compare packed unsigned 16-bit integers in "a" and "b", and store packed maximum values in "dst".

__m128i _mm_max_epu16 (__m128i a, __m128i b)
PMAXUW xmm, xmm/m128

## mm_max_epu32

`mm_max_epu32`

Compare packed unsigned 32-bit integers in "a" and "b", and store packed maximum values in "dst".

__m128i _mm_max_epu32 (__m128i a, __m128i b)
PMAXUD xmm, xmm/m128

## mm_min_epi32

`mm_min_epi32`

Compare packed 32-bit integers in "a" and "b", and store packed minimum values in "dst".

__m128i _mm_min_epi32 (__m128i a, __m128i b)
PMINSD xmm, xmm/m128

## mm_min_epi8

`mm_min_epi8`

Compare packed 8-bit integers in "a" and "b", and store packed minimum values in "dst".

__m128i _mm_min_epi8 (__m128i a, __m128i b)
PMINSB xmm, xmm/m128

## mm_min_epu16

`mm_min_epu16`

Compare packed unsigned 16-bit integers in "a" and "b", and store packed minimum values in "dst".

__m128i _mm_min_epu16 (__m128i a, __m128i b)
PMINUW xmm, xmm/m128

## mm_min_epu32

`mm_min_epu32`

Compare packed unsigned 32-bit integers in "a" and "b", and store packed minimum values in "dst".

__m128i _mm_min_epu32 (__m128i a, __m128i b)
PMINUD xmm, xmm/m128

## mm_minpos_epu16

`mm_minpos_epu16`

Horizontally compute the minimum amongst the packed unsigned 16-bit integers in "a", store the minimum and index in "dst", and zero the remaining bits in "dst".

__m128i _mm_minpos_epu16 (__m128i a)
PHMINPOSUW xmm, xmm/m128

## mm_mpsadbw_epu8

`mm_mpsadbw_epu8`

Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in "a" compared to those in "b", and store the 16-bit results in "dst".
	Eight SADs are performed using one quadruplet from "b" and eight quadruplets from "a". One quadruplet is selected from "b" starting at on the offset specified in "imm8". Eight quadruplets are formed from sequential 8-bit integers selected from "a" starting at the offset specified in "imm8".

__m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8)
MPSADBW xmm, xmm/m128, imm8

## mm_mul_epi32

`mm_mul_epi32`

Multiply the low 32-bit integers from each packed 64-bit element in "a" and "b", and store the signed 64-bit results in "dst".

__m128i _mm_mul_epi32 (__m128i a, __m128i b)
PMULDQ xmm, xmm/m128

## mm_mullo_epi32

`mm_mullo_epi32`

Multiply the packed 32-bit integers in "a" and "b", producing intermediate 64-bit integers, and store the low 32 bits of the intermediate integers in "dst".

__m128i _mm_mullo_epi32 (__m128i a, __m128i b)
PMULLD xmm, xmm/m128

## mm_packus_epi32

`mm_packus_epi32`

Convert packed 32-bit integers from "a" and "b" to packed 16-bit integers using unsigned saturation, and store the results in "dst".

__m128i _mm_packus_epi32 (__m128i a, __m128i b)
PACKUSDW xmm, xmm/m128

## mm_round_pd1

`mm_round_pd1`

Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION); ROUNDPD xmm, xmm/m128, imm8(4)

## mm_round_pd1_to_nearest_integer

`mm_round_pd1_to_nearest_integer`

Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_round_pd (__m128d a, int rounding)
ROUNDPD xmm, xmm/m128, imm8(8)
            _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC

## mm_round_pd1_to_negative_infinity

`mm_round_pd1_to_negative_infinity`

Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(9)

## mm_round_pd1_to_positive_infinity

`mm_round_pd1_to_positive_infinity`

Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(10)

## mm_round_pd1_to_zero

`mm_round_pd1_to_zero`

Round the packed double-precision (64-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed double-precision floating-point elements in "dst".

__m128d _mm_round_pd (__m128d a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC); ROUNDPD xmm, xmm/m128, imm8(11)

## mm_round_ps

`mm_round_ps`

Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION); ROUNDPS xmm, xmm/m128, imm8(4)

## mm_round_ps_to_nearest_integer

`mm_round_ps_to_nearest_integer`

Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_round_ps (__m128 a, int rounding)
ROUNDPS xmm, xmm/m128, imm8(8)
            _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC

## mm_round_ps_to_negative_infinity

`mm_round_ps_to_negative_infinity`

Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(9)

## mm_round_ps_to_positive_infinity

`mm_round_ps_to_positive_infinity`

Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(10)

## mm_round_ps_to_zero

`mm_round_ps_to_zero`

Round the packed single-precision (32-bit) floating-point elements in "a" using the "rounding" parameter, and store the results as packed single-precision floating-point elements in "dst".

__m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC); ROUNDPS xmm, xmm/m128, imm8(11)

## mm_round_sd

`mm_round_sd`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION)
ROUNDSD xmm, xmm/m128, imm8(4)

## mm_round_sd1

`mm_round_sd1`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION)
ROUNDSD xmm, xmm/m128, imm8(4)

## mm_round_sd1_to_nearest_integer_scalar

`mm_round_sd1_to_nearest_integer_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(8)

## mm_round_sd1_to_negative_infinity_scalar

`mm_round_sd1_to_negative_infinity_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(9)

## mm_round_sd1_to_positive_infinity_scalar

`mm_round_sd1_to_positive_infinity_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(10)

## mm_round_sd1_to_zero_scalar

`mm_round_sd1_to_zero_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(11)

## mm_round_sd_to_nearest_integer_scalar

`mm_round_sd_to_nearest_integer_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(8)

## mm_round_sd_to_negative_infinity_scalar

`mm_round_sd_to_negative_infinity_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(9)

## mm_round_sd_to_positive_infinity_scalar

`mm_round_sd_to_positive_infinity_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(10)

## mm_round_sd_to_zero_scalar

`mm_round_sd_to_zero_scalar`

Round the lower double-precision (64-bit) floating-point element in "b" using the "rounding" parameter, store the result as a double-precision floating-point element in the lower element of "dst", and copy the upper element from "a" to the upper element of "dst".

__m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC)
ROUNDSD xmm, xmm/m128, imm8(11)

## mm_round_ss

`mm_round_ss`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION)
ROUNDSS xmm, xmm/m128, imm8(4)

## mm_round_ss1

`mm_round_ss1`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION)
ROUNDSS xmm, xmm/m128, imm8(4)

## mm_round_ss1_to_nearest_integer_scalar

`mm_round_ss1_to_nearest_integer_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(8)

## mm_round_ss1_to_negative_infinity_scalar

`mm_round_ss1_to_negative_infinity_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(9)

## mm_round_ss1_to_positive_infinity_scalar

`mm_round_ss1_to_positive_infinity_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(10)

## mm_round_ss1_to_zero_scalar

`mm_round_ss1_to_zero_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(11)

## mm_round_ss_to_nearest_integer_scalar

`mm_round_ss_to_nearest_integer_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(8)

## mm_round_ss_to_negative_infinity_scalar

`mm_round_ss_to_negative_infinity_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(9)

## mm_round_ss_to_positive_infinity_scalar

`mm_round_ss_to_positive_infinity_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(10)

## mm_round_ss_to_zero_scalar

`mm_round_ss_to_zero_scalar`

Round the lower single-precision (32-bit) floating-point element in "b" using the "rounding" parameter, store the result as a single-precision floating-point element in the lower element of "dst", and copy the upper 3 packed elements from "a" to the upper elements of "dst".

__m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)
ROUNDSS xmm, xmm/m128, imm8(11)

## mm_stream_load_si128

`mm_stream_load_si128`

Load 128-bits of integer data from memory into "dst" using a non-temporal memory hint.
	"mem_addr" must be aligned on a 16-byte boundary or a general-protection exception may be generated.

__m128i _mm_stream_load_si128 (const __m128i* mem_addr)
MOVNTDQA xmm, m128

## mm_testc_si128

`mm_testc_si128`

Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "CF" value.

int _mm_testc_si128 (__m128i a, __m128i b)
PTEST xmm, xmm/m128

## mm_testnzc_si128

`mm_testnzc_si128`

Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return 1 if both the "ZF" and "CF" values are zero, otherwise return 0.

int _mm_testnzc_si128 (__m128i a, __m128i b)
PTEST xmm, xmm/m128

## mm_testz_si128

`mm_testz_si128`

Compute the bitwise AND of 128 bits (representing integer data) in "a" and "b", and set "ZF" to 1 if the result is zero, otherwise set "ZF" to 0. Compute the bitwise NOT of "a" and then AND with "b", and set "CF" to 1 if the result is zero, otherwise set "CF" to 0. Return the "ZF" value.

int _mm_testz_si128 (__m128i a, __m128i b)
PTEST xmm, xmm/m128

repository: scottbilas/kalk

repo_name: scottbilas/kalk


text:
# Coroutine Scope vs Coroutine Context

## CoroutineContext

Coroutines always execute in some context represented by a value of the `CoroutineContext` type, defined in the Kotlin standard library.

```
/**
 * Persistent context for the coroutine.
 * It is an indexed set of [Element] instances.
 * An indexed set is a mix between a set and a map.
 * Every element in this set has a unique [Key].
 */
@SinceKotlin("1.3")
public interface CoroutineContext
```

`CoroutineContext` is just a `Map` that stores a set of `Element` objects that have a unique `Key`.

![](./res/coroutine_context.png "CoroutineContext")

An `Element` is anything a coroutine might need to run correctly. The most common examples would be:

- `Job` - a cancellable handle to a coroutine with a lifecycle;
- `CoroutineDispatcher`, `MainCoroutineDispatcher` - dispatchers for a coroutine to run on;
- `CoroutineId`, `CoroutineName` - elements mainly used to debug coroutines;
- `CoroutineExceptionHandler` - an element that handles uncaught exceptions;
- `Continuation Interceptor` - allows one to define how coroutines should continue.

## CoroutineScope

A `CoroutineScope` is just a simple wrapper for a `CoroutineContext`. In a technical sense, it is nothing more than a `CoroutineContext`, and the only reason it exists and has a different name is to **differentiate the intended purpose of the two**.

```
public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}
```

`CoroutineScope` performs the following functions:
- Provides an abstraction for manipulate contexts and jobs, help us to manage them;
- `CoroutineScope` also keeps track of all its children's scopes. e.g. when perform a `launch` within another scope, a child scope is created automatically;
- It provides all the utilities to `launch`, `async`, and also `cancel` etc…;
- Enforce structured concurrency.

![](./res/coroutine_scope.png "CoroutineScope")

# Links
[Coroutine context and dispatchers](https://kotlinlang.org/docs/coroutine-context-and-dispatchers.html)

[Things every Kotlin Developer should know about Coroutines. Part 1: CoroutineContext](https://maxkim.eu/things-every-kotlin-developer-should-know-about-coroutines-part-1-coroutinecontext)

[Things every Kotlin Developer should know about Coroutines. Part 2: CoroutineScope](https://maxkim.eu/things-every-kotlin-developer-should-know-about-coroutines-part-2-coroutinescope)

[Kotlin Coroutine Scope, Context, and Job made simple](https://medium.com/mobile-app-development-publication/kotlin-coroutine-scope-context-and-job-made-simple-5adf89fcfe94)

# Futher reading
[Coroutine Context and Scope](https://elizarov.medium.com/coroutine-context-and-scope-c8b255d59055)

url: https://raw.githubusercontent.com/Kirchhoff-/Android-Interview-Questions/2f1a8e68612d434ac6454d1c077e72d241c93afa/Kotlin/What is Coroutine Scope and how is that different from Coroutine Context?.md

repository: Kirchhoff-/Android-Interview-Questions

repo_name: Kirchhoff-/Android-Interview-Questions


text:
Create a function that takes a string (the string to truncate) and a number (the *maximum*length of the truncated string) as arguments and returns the truncated string at the given length.

*   If a word is trucated in the middle, discard it in the output (see 2nd example above).


text:
Project Description
-------------------

The XDI graph editor project is, as the name implies, a graphic editor for
visualizing and manipulating XDI graphs. XDI is an OASIS Technical committee
whose purpose is to define a format and protocol for semantic data interchange
using a standard addressable semantic graph model serialized in JSON (see [1]
for more details).

Project Setup
-------------
This project relies on the D3 javascript library ([2][]). This library will be
automatically retrieved upon launch of the editor.

The tool also leverages an XDI javascript library (xdi.js). this library is
included in the tool archive (see [6][] for more details).

Finally, the tool uses JQuery ([4][]). This library will also be automatically
retrieved upon launch of the editor.

Deploying
---------
Once the file archive file has been downloaded and unziped, simply load the
index.html file in your browser.

Troubleshooting & Useful Tools
------------------------------
Both a manual and a tutorial are available within the tool: click on the Help
button on the top right corner of the browser window.

It is strongly recommended to go through the tutorial before attempting to
manipulate your own XDI graphs.

Contributors
------------
If you find a bug or would like to suggest improvements, please use the issue
tracker available on GitHub.

Acknowledgements
----------------
The graph editing functionality of this tool is largely based on the D3
directed graph editor (see [3][]) although it has been greatly modified since then.

License
-------
This tool is made available under the MIT license (see [5][] for details).

[1]: https://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xdi
[2]: http://d3js.org/d3.v3.min.js
[3]: http://bl.ocks.org/rkirsling/5001347
[4]: http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js
[5]: http://opensource.org/licenses/MIT
[6]: https://github.com/projectdanube/xdi-js

repository: projectdanube/xdi-grapheditor

repo_name: projectdanube/xdi-grapheditor


text:
# διάδημα -τος, τό

<!-- Status: S2=NeedsFinalCheck -->
<!-- Lexica used for edits:   -->

## Word data

* Strongs: G12380

* Alternate spellings:

* Principle Parts:

* Part of speech:

[Noun](http://ugg.readthedocs.io/en/latest/noun.html);

* Instances in NT: 3

* All Scriptures cited: No

## Etymology:

* LXX/Hebrew glosses:

* Time Period/Ancient Authors:

* Related words: [διαδέω](), to bind round);

* Antonyms for all senses

* Synonyms for all senses:

 [στέφανος](../G47350/01.md), the badge of "victory, of valour, of nuptial joy, of festal gladness " (but see M, Th., i, 219; cf. DB, i, 530, 604).

## Senses

### Sense  1.0:

#### Definition:

a crown, diadem;

#### Glosses:

a crown, diadem;

#### Explanation:

#### Citations:

the band round the [τιάρα]() of a Persian king; a diadem, the badge of royalty: [Re 12:3](Rev 12:3); [13:1](Rev 13:1); [19:12](Rev 19:12).†

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# learn-dutch

[![Codacy Badge](https://api.codacy.com/project/badge/Grade/2519b0c4a99741e385cd6d54110e189b)](https://www.codacy.com/app/Suddi/learn-dutch)
[![license](https://img.shields.io/github/license/suddi/learn-dutch.svg)](https://github.com/suddi/learn-dutch/blob/master/LICENSE)

My personal journey learning Dutch with Jupyter Notebook

## Setup

````sh
pip install --requirement requirements.txt --requirement test_requirements.txt
````

## Usage

````sh
jupyter-notebook
````

repository: suddi/learn-dutch

gha_language: Jupyter Notebook

repo_name: suddi/learn-dutch


text:
App RTPProxy Log filter
---

Status : functional, experimental plugin.

The vendor filter is used to extract IP:PORT stream to session correlation vectors from RTPProxy debug logs.

Example 1: parse debug logs.
````
filter {
  app_rtpproxy {}
}
`````

Parameters:

* none

repository: sipcapture/paStash

branch_name: refs/heads/next

repo_name: sipcapture/paStash


text:
---
layout: course
title: Intermediate Excel I
description: This classroom based workshop is the second in a series of workshops on Excel offered by the Data Academy. It builds on the fundamentals of Excel and introduces more advanced ways to manipulate and format data in spreadsheets.
prerequisites: None
length: 2
series:
  - Excel
subjects:
  - Analysis
  - Visualization
team_members:
  - aaron-low
  - ashley-groffenberger
  - celeste-berg
  - david-weinzimmer
  - jessie-rubin
  - sam-abbott
course_materials_link:
order: 2
---

## About this course

This classroom based workshop is the second in a series of workshops on Excel offered by the Data Academy. It builds on the fundamentals of Excel and introduces more advanced ways to manipulate and format data in spreadsheets.

This course is a natural continuation of our Introduction to Excel training.

## What you’ll learn

* Paste Special, Text to Columns, and Concatenate
* VLOOKUP
* IF, IFERROR
* Tables
* PivotTables and PivotCharts
* Making charts presentable
* Printing, formatting, and sharing spreadsheets/charts
* Conditional formatting


text:
# Object Pile

## Overview

**Object Pile** is a technique of utilization of large amounts of RAM - (tens to hundreds of gigabytes) in-process in server applications via **regular CLR object** allocations, making **Big Memory** applications possible on a 100% managed runtime.

**Pile solves the notorious GC stalls problem** which existed since the first days of managed memory model. Unfortunately, the GC blocking can not be eradicated completely - it is the price we have to pay for the higher-level memory model. In recent years there have been significant improvements in GC mechanisms [see this MSDN blog post](https://blogs.msdn.microsoft.com/dotnet/2012/07/20/the-net-framework-4-5-includes-new-garbage-collector-enhancements-for-client-and-server-apps/). The GC became less intrusive, and more informative, so  we can now know about the upcoming  blocking GC phase and try to divert traffic to a nearby server. This has helped many use-cases.

There is a number of systems, however, where GC remains problematic despite all of the improvements made in the runtime. It is a customary routine to use the out-of-box/process solutions such as Redis in such systems, however keep in mind that out-of-process stores still require serialization and transportation overhead.

**The GC starts to interfere when:**
*(regardless of GC mode, concurrency, notification and critical regions)*

* A process needs to store 100s of millions of objects and have predictable SLA (response times and throughput)
* Long-lived objects (i.e. days) - so they all go to Gen2
* Objects are mutable - data changes, (not a read-only set)
* Locality of reference (box-bound dataset) is important

Big Memory Pile solves the GC problems by using the transparent serialization of CLR object graphs into large byte arrays, effectively “hiding” the objects from GC’s reach. Not all object types need to be fully serialized  - strings and byte[] get written into Pile as buffers bypassing all serialization mechanisms yielding over 6 M inserts/second for a 64 char string on a 6 core box.

The key benefit is the **practicality** of this **approach which obviates the need to construct custom DTOs and other hack methods just to relieve the pressure on the GC**. The real life cases have shown the overall performance of the solution to be much higher than using external stores.

## How it Works
Pile provides a layered design, at its core there is a [memory allocator](PileImpl/DefaultPileBase.cs) that manages the sub-allocation within large ["segments"](PileImpl/DefaultPileBase.Segment.cs) which are backed by either [byte[]](PileImpl/LocalMemory.cs) or [MemoryMappedFiles](PileImpl/MMFMemory.cs).

The main point of Pile is to exchange a CLR reference (which GC "sees") for a [PilePointer](PilePointer.cs) value type ( a `struct` of 3 ints which GC does not "see"). After you put an object into Pile, you need to keep a `PilePointer` reference (somewhere, see Cache below) which is invisible to GC and can be used later to resurrect the original object back into "real" CLR heap.

The `PilePointer` instances can be kept in regular CLR heap, in classes like `List<>` or `Dictionary<>` as they do not create any GC scan pressure. They can also be kept in other objects stored directly in Pile, thus it is possible to create **complex data structures (i.e. a PrefixTree)** that contains hundreds of millions of entries **completely in Pile**.

When you put an object into a Pile (or cache), it treats `byte[]` ans `string` primitives as **directly writable into the memory** buffer, - this is called a "raw" mode - it works **much faster than arbitrary objects** as it bypasses serialization completely *(see benchmarks below)*. Other objects get serialized using [Slim serializer](../../Serialization/Slim/SlimSerializer.cs) which is very efficient at turning true CLR object graphs (even with cycles and polymorphism) into `byte[]`.

Azos features [ICache](ICache.cs) store which is based on [IPile](IPile.cs) memory manager. This allows for storage of very many objects in named tables - out of GC's reach. Tables are akin to thread-safe named dictionary instances.

Azos solution provides a full-featured in-process caching server implementation of [ICache](ICache.cs) interface - [LocalCache](LocalCache.cs). As described above, the benefit of local cache is in the fact of in-process data availability - no socket connections/context switching needs to take place, consequently the performance is higher than that of an out-of-process store.

## Performance
Machine: Intel Core i7-3930K 3.2. Ghz, 6 HT Cores, 64 GB DDR3 87% free, Win 7 64bit, VS 2017, .NET 4.5, mid-grade SSD 1 TB 50% free

--------
Benchmarking Pile - insert **200,000,000** instances of **string[32]** each, by **12 threads**:

|    | Default Pile  |   MMF Pile   |
|----|-----------|--------------|
| Duration   | 24 sec |  41 sec |
| Throughput | 8.3M ops/sec | 4.9M ops/sec|
| RAM        | 8.5 GB  |  8.5 GB|
| Full GC    | < 8 ms  | < 10ms |
| Flush all data on Stop() | - | 10 sec|
| Load all data on Start()| - | 48 sec @ 177 mbyte/sec|

--------

Benchmarking Pile - insert **200,000,000** instances of **Person** (class with [7 fields](https://github.com/azist/azos/blob/master/Source/Testing/Manual/WinFormsTest/PileForm.cs#L77-L84)), by **12 threads**:

|    | Default Pile  |   MMF Pile   |
|----|-----------|--------------|
| Duration   | 85 sec |  101 sec |
| Throughput | 2.4M ops/sec | 1.9M ops/sec|
| RAM        | 14.5 GB  |  14.5 GB|
| Full GC    | < 10 ms  | < 10ms |
| Flush all data on Stop() | - | 30 sec|
| Load all data on Start() | - | 50 sec @ 290 mbyte/sec|

## Examples
[IPile](IPile.cs) provides an abstraction of memory managers. Azos framework provides two implementations out of the box:
* [DefaultPile](DefaultPile.cs) - stores data in byte[]
* [MMFPile](MMFPile.cs) - stores data in Memory Mapped Files
Both implemntations are 100% managed code C# only, no C++ involved.

**1 - Create IPile-implementing Instance**

Depending on your objectives you can allocate Pile by hand, or use dependency injection:

```cs
  private IPileImplemntation m_Pile;
  .....
  //make by hand
  m_Pile = new DefaultPile(App);// If you do not have App context, use NOPApplication.Instance instead
  //or
  m_Pile = new MMFPile(App);// If you do not have App context, use NOPApplication.Instance instead
  //or inject from config
  //if type is not specified in config use DefaultPile as default type
  m_Pile = FactoryUtils.MakeAndConfigure(configNode, typeof(DefaultPile));
  .....
  m_Pile.Start();//Start the service

  .... use pile ....

  //finalize:
  m_Pile.WaitForCompleteStop();
  m_Pile.Dispose();
  //or just 1 line instead of the 2
  DisposableObject.DisposeAndNull(ref m_Pile);
```
The MMFPile requires setting the `DataDirectoryRoot` to an existing folder, otherwise the MMPile would not start.

**2 - Use Raw Memory Allocator**

Raw memory allocator works with byte[] bypassing any serialization; this code yeilds multi-million ops/sec while inserting byte[64]:

```cs
  var buffer = new byte[1234];
  var ptr = pile.Put(buffer);
  ...
  var got = pile.Get(ptr) as byte[];
  Aver.IsNotNull(got);
  Aver.AreEqual(1234, got.Length);

```
we can do the same with strings, as strings use UTF8 direct encoding into memory buffer. The performance is similar.

**3 - Working with CLR objects**

The **major business benefit of the Pile** is that it allows you to work with pretty much **any .NET types without special treatment**. You do not need to create and maintain extra DTO copies, instead - work with your business domain.

Working with regular .NET objects is no different than the example above, byte[] and strings are special types that bypass serializer altogether, whereas any other types go via SlimSerializer which is used in the special Batch mode for performance. See the [IPile Interface](IPile.cs).

There are a few cases that Pile does not support by design:
* Classes with unmanaged handles/resources (unless they are serializable via ISerializable/[OnSer/Deser] mechanisms)
* Delegates/function pointers

```cs
  var person = new Person{ LastName="Shoikhed", FirstName="Dodik", Age=54 };
  var ptr = pile.Put(person);
  ...
  var got = pile.Get(ptr) as Person;
  Console.WriteLine( got.LastName );//Shoikhed
```

An example of a linked list with in-place mutation (changing data at existing pointer):

```cs
  public class ListNode
  {
    public PilePointer Previous;
    public PilePointer Next;
    public PilePointer Value;
  }
  ...
  private IPile m_Pile;//big memory pile
  private PilePointer m_First;//list head
  private PilePointer m_Last;//list tail
  ...
  //Append a person instance to a person linked list stored in a Pile
  //returns last node
  public PilePointer Append(Person person)
  {
    var pValue = m_Pile.Put(person);

    var newLast = new ListNode{ Previous = m_Last,
                                Next = PilePointer.Invalid,
                                Value = pValue};

    var existingLast = m_Pile.Get(m_Last);
    existingLast.Next = node;
    m_Pile.Put(m_Last, existingLast);//in-place edit at the existing ptr m_Last
    m_Last = m_Pile.Put(newLast);//add new node to the tail

    return m_Last;
  }
```

Keep in mind: if you serialize a huge object graph into a Pile - it will accept that graph as long as it fits in a single segment (256 Mb by default), however this is not a good and intended pattern of using Pile by design. Instead, store smaller business-oriented objects. If you need to store huge graphs use [ICache](ICache.cs) (see below).

**4 - Caching**

Making cache instance:
```cs
  var cache = new LocalCache(App);// If you do not have App context, use NOPApplication.Instance instead
  cache.Pile = new DefaultPile(cache);//Pile owned by cache
  cache.Configure(conf);
  cache.Start();
     ...
     //use
     ...
  //this will dispose Pile because it is owned by cache
  DisposableObject.DisposeandNull(ref cache);
```
Put all tables in the `Durable` CollisionMode. In this mode no data is going to get lost. Cache tables will work just like dictionary. In the `Speculative` mode the tables skip rehashing for speed - hence some data may get lost as governed by item `priority` on `Put()`:

```cs
  //Specify TableOptions for ALL tables
  cache.DefaultTableOptions = new TableOptions("*")
  {
    CollisionMode = CollisionMode.Durable
  };
```

Create tables and put some data, note the **use of comparers**:

```cs
   var tA = cache.GetOrCreateTable<string>("A", StringComparer.Ordinal);
   var tB = cache.GetOrCreateTable<string>("B", StringComparer.OrdinalIgnoreCase);

   Aver.AreEqual(PutResult.Inserted, tA.Put("key1", "avalue1"));
   Aver.AreEqual(PutResult.Inserted, tA.Put("Key1", "avalue2"));
   Aver.AreEqual(PutResult.Inserted, tB.Put("key1", "bvalue1"));
   Aver.AreEqual(PutResult.Replaced, tB.Put("Key1", "bvalue2"));
```

Max age, priority and absolute expiration:
```cs
  var tA = cache.GetOrCreateTable<int>("A");
  var data = new Person{...};
  var theEnd = App.TimeSource.UTCNow.AddHours(73);
  ta.Put(123, myData, maxAgeSec: 78000, priority: 2, absoluteExpirationUTC: theEnd);
  .....

  //set existing object age filter
  var newPerson = tA.Get(123, ageSec: 32) as Person;
  if (newPerson!=null)...
  ....
  ta.Rejuvenate(123);//true - reset object age to zero
  ....
  tA.Remove(123);//true
```

Enumerate all entries:
```cs
 var tA = cache.GetOrCreateTable<int>("A");
 var all = tA.AsEnumerable(withValues: true);

 foreach(var entry in all)
 {
    ...
    entry.Key
    entry.AgeSec
    entry.Priority
    entry.MaxAgeSec
    entry.ExpirationUTC

    // Returns value only if enumerator is in materializing mode,
    //obtained by a call to AsEnumerable(withValues: true)
    entry.Value
 }
```

Imposing limits:
```cs
  var tA = cache.GetOrCreateTable<int>("A");
  tA.Options.MaximumCapacity = 1800;
  tA.Options.ShrinkFactor = 0.5d;
```

Atomic GetOrPut():
```cs
  var tA = cache.GetOrCreateTable<int>("A");

  tA.Put(1, "value 1");
  tA.Put(122, "value 122");

  PutResult? pResult;
  var v = tA.GetOrPut(2, (t, k, _) => "value "+k.ToString(), null, out pResult);
  Aver.AreEqual( "value 2", v);
  Aver.IsTrue( pResult.HasValue );
  Aver.AreEqual( PutResult.Inserted, pResult.Value);
```

Configure tables individually:
```cs
store
{
  default-table-options
  {
    initial-capacity=1000000
    detailed-instrumentation=true
  }

  table
  {
    name='A'
    minimum-capacity=800000
    maximum-capacity=987654321
    initial-capacity=780000
    growth-factor=2.3
    shrink-factor=0.55
    load-factor-lwm=0.1
    load-factor-hwm=0.9
    default-max-age-sec=145
    detailed-instrumentation=true
  }

  table
  {
    name='B'
    maximum-capacity=256000
    detailed-instrumentation=false
  }
}
```

## Resources
The topic has been covered at length here:

[InfoQ -Big Memory .NET Part 1 – The Challenges in Handling 1 Billion Resident Business Objects](https://www.infoq.com/articles/Big-Memory-Part-1)

[InfoQ -Big Memory .NET Part 2 – The Challenges in Handling 1 Billion Resident Business Objects](https://www.infoq.com/articles/Big-Memory-Part-2)

repository: azist/azos

gha_language: C#

repo_name: azist/azos


text:
# cookie
A demo about how to add, get and delete cookies.
  you can see the code by clicking 'show code'

You also can test how many cookies you can stored in this browser.
  (In my test, chrome: 140 - 180; firefox: 150; ie 11: 50; edge: 50)

repository: jsososo/cookie

repo_name: jsososo/cookie


text:
log_bleach - make the cruft disappear from your log files

* auto_tune (put regexes that match the most often earliest in the pattern list)
* multiple files at once support (can easily use xargs in the mean time)

log_bleach log_file_name

* option to specify the filter "level" (so you can choose to leave certain data in the output),
* option to force-tiemstamp (add timestamps to the output when the input file didn't have timestamps.

log_bleach log_file_source_directory  log_file_target_directory

* for each file under the source directory, filter as above into a matching named extract file in the target directory
* In an ideal world, every file in the target directory would be empty!
* Everything in the filtered extracts is either a bug, or something else to add to the irrelevant filter for that log file type

gha_language: Perl


text:
# Organization

Underneath `cases` live test cases. Each case consists of the following:

* `test.js` - a javascript which exports the configuration spec and process environment
* `test_xxx.json` - one or more JSON configuration files interpreted in sorted order
* `test.out` - a JSON file containing the expected final configuration, or error string

repository: mozilla/node-convict

gha_license_id: NOASSERTION

repo_name: mozilla/node-convict


text:
---
layout: page
title: S5
permalink: /resources-s5/
---

## **Computer Graphics**
[Syllabus][cg-syll] *( Credits: 3 )*

[Previous Year Question Paper][cg-prev]

## **UNIX**
[Syllabus][unix-syll] *( Credits: 3 )*

Previous Year Question Papers:  [Regular][unix-prev-1] / [Supplementary][unix-prev-2]
# Websites:
* [Tutorials Point](https://www.tutorialspoint.com/unix/)
* [Writing Unix Scripts](https://web.calpoly.edu/~rasplund/script.html)
* [UNIX Interview Questions](https://linoxide.com/linux-shell-script/shell-scripting-interview-questions-answers/)
* [GNU plot](https://people.duke.edu/~hpgavin/gnuplot.html)
* [GCC and Make](http://www.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html)
* [Linux Shell Scripting Tutorial](https://bash.cyberciti.biz/guide/Main_Page)
* [Unix Comparisions](http://tldp.org/LDP/abs/html/comparison-ops.html)
* [AWK Manual](http://www.cs.unibo.it/~renzo/doc/awk/nawkA4.pdf)

# Post Series
* [AWK][unix-awk]
* [Shell jobs][unix-shell-jobs]

## **Computer Networks**
[Syllabus][net-syll] *( Credits: 3 )*

Previous Year Question Papers: [Regular][net-prev-1] / [Supplementary][net-prev-2]

## **Operating Systems**
[Syllabus][os-syll] *( Credits: 3 )*

Previous Year Question Papers: [Regular][os-prev-1] / [Supplementary][os-prev-2]
# Series 1:
* [Process creation, Coordination and Synchronization][PCS]
* [Operating System Structures][Section03-Structures]
* [Processes][Section04-Processes4 class]
* [Scheduling][Section05-Scheduling 4clas final]
* [Operating systems overview][operating_systems_overview]

# Series 2:
* [Classic problems of synchronisation][os-classic-sync]
* [Critical region and solutions][os-critic]
* [Deadlocks][os-deadlock]
* [Deadlocks more][os-deadlocks-more]
* [IO Systems][os-io-sys]
* [Disk Scheduling Algorithms][os-disk]

# Post Series
* [Memory Management][os-mm]
* [Segmented Paging][os-seg-page]
* [Virtual Memory][os-vm]
* [File Systems][os-fs]
* [File Structures][os-fstruct]

## **Software Architecture**
[Syllabus][sof-syll] *( Credits: 4 )*

Previous Year Question Papers: [Regular][soft-prev-1] / [Supplementary][soft-prev-2]
# Series 1:
* [Process models][process-models]
* [Software Design Principles][soft-design-principles]
* [Chapter 1: Introduction to Software Engg][chap-1]
* [Chapter 3: Software Process Model][chap-3]
* [Goals of software design][goal-soft]
* UML
  * [Types of UML Diagrams][types-UML]
  * [Usecase Example][use-ex]
  * [Use case diagram for Banking][use-bank]
  * [Use case diagram for ATM machine][use-atm]

# Series 2:
* Class Diagrams
  * [Notes][soft-class-notes]
  * [Online Shopping example][soft-shop]
  * [Library Management System example][soft-lib]
* Activity diagram
  * [Notes1][activity-diagram]
  * [Notes2][activity-diagram2]
  * Online shopping system [img1][act-shop-img1] / [img2][act-shop-img2]
* [State Diagram][sadp-state]
* [Interaction Diagrams][sadp-interaction]
* [Deployment Diagram][sadp-deploy]
* [Software Architecture Styles][soft-arch-styles]
* [Model view controller architecture][soft-mvc]

# Post Series:
* [Design principles I: Correctness and Robustness][sadp-dp-1]
* [Design principles II: Flexibility, Reusability and Efficiency][sadp-dp-2]
* [Introduction to ATAM][atam-sadp]
* [ATAM][sadp-atam]

## **Microprocessor and Microcontroller**
[Syllabus][mic-syll] *( Credits: 3 )*

Previous Year Question Papers: [Regular][micro-prev-1] / [Supplementary][micro-prev-2]
# Series 1:
* [Module 1][module_1]
* [Instruction set of 8086][8086-instruction-set]
* [Module 2][module_2]
* [Procedure and macros][macros_ppt]
* [Intra segment Direct/Indirect mode][intra_direct_indirect]
* [Inter segment Direct/Indirect mode][inter_direct_indirect]
* [Relative based index addressing][rel_index_add]
* [Jump instructions(JA-JZ)](http://www.penguin.cz/~literakl/intel/j.html)

# Series 2:
* [Microcontroller Intro][microintro]
* [8051 architecture][8051arch]
* [8051 addressing modes][8051add]
* [8051 notes][8051notes]

# Post Series
* [8254][micro-8254]
* [8255][micro-8255]
* [8257][micro-8257]
* [8259][micro-8259]
* [8279][micro-8279]

## **Theory of Computation**
[Syllabus][toc-syll] *( Credits: 3 )*

Previous Year Question Papers: [Regular][toc-prev-1] / [Supplementary][toc-prev-2]
# Series 1:
* [TOC notes][t-note]

# Websites:
* [Neso Academy](https://www.youtube.com/watch?v=58N2N7zJGrQ&list=PLBlnK6fEyqRgp46KUv4ZY69yXmpwKOIev)

## **Database Lab**
* Postgres notes [PDF][dblab-post-pdf] / [SQL][dblab-post-sql]
* Questions [PDF][dblab-ques-pdf] / [SQL][dblab-ques-sql]
* Functions [PDF][dblab-func-pdf] / [SQL][dblab-func-sql]

# Websites:
 * [Tutorials Point](https://www.tutorialspoint.com/postgresql/)

[micro-prev-1]: /resources/MICROPROCESSOR/CS305._S5_Dec_17_Regular.pdf
[micro-prev-2]: /resources/MICROPROCESSOR/CS305_S.pdf
[mic-syll]: /resources/MICROPROCESSOR/CS305_Microprocessors_and_microcontrollers.pdf
[8086-instruction-set]: /resources/MICROPROCESSOR/series1/instruction-set-of-8086.pptx
[module_2]: /resources/MICROPROCESSOR/series1/Module_2.pptx
[module_1]: /resources/MICROPROCESSOR/series1/mod1.pptx
[macros_ppt]: /resources/MICROPROCESSOR/series1/procedure_and_macros.ppt
[intra_direct_indirect]: /resources/MICROPROCESSOR/series1/intra_direct_indirect.jpeg
[inter_direct_indirect]: /resources/MICROPROCESSOR/series1/inter_direct_indirect.jpeg
[rel_index_add]: /resources/MICROPROCESSOR/series1/relative_based_index_addressing.jpeg
[microintro]: /resources/MICROPROCESSOR/series2/microcontroller_intro.pptx
[8051arch]: /resources/MICROPROCESSOR/series2/8051arch.ppt
[8051add]: /resources/MICROPROCESSOR/series2/addressingmodes8051.ppt
[8051notes]: /resources/MICROPROCESSOR/series2/8051mc-notes-121004121921-phpapp01.pdf
[micro-8255]: /resources/MICROPROCESSOR/series2/8255.ppt
[micro-8259]: /resources/MICROPROCESSOR/series2/8259.ppt
[micro-8257]: /resources/MICROPROCESSOR/series2/8257_DMA_Controller.pptx
[micro-8279]: /resources/MICROPROCESSOR/series2/8279b.pptx
[micro-8254]: /resources/MICROPROCESSOR/8254.pptx

[os-prev-1]: /resources/OS/IT305-A.pdf
[os-prev-2]: /resources/OS/IT305_S.pdf
[os-syll]: /resources/OS/IT305_Operating_systems.pdf
[PCS]: /resources/OS/series1/processcreation_coorporation_synchronization.ppt
[Section03-Structures]: /resources/OS/series1/Section03-Structures.ppt
[Section04-Processes4 class]: /resources/OS/series1/Section04-Processes4_class.ppt
[Section05-Scheduling 4clas final]: /resources/OS/series1/Section05-Scheduling_4clas_final.ppt
[operating_systems_overview]: /resources/OS/series1/operating_systems_overview.ppt
[os-classic-sync]: /resources/OS/series2/Classic_problems_of_synchronisation.ppt
[os-critic]: /resources/OS/series2/Critical_region_and_solutions-Sync1.ppt
[os-deadlock]: /resources/OS/series2/Section07-Deadlocks.ppt
[os-io-sys]: /resources/OS/series2/Section12-IO_Systems.ppt
[os-disk]: /resources/OS/series2/Disk_Scheduling_Algorithms-GeeksforGeeks.pdf
[os-deadlocks-more]: /resources/OS/series2/Section07-Deadlocks-more.ppt
[os-vm]: /resources/OS/series2/Section09-Virtual_Memory.ppt
[os-fs]: /resources/OS/series2/Section10-File_Systems.ppt
[os-mm]: /resources/OS/series2/Section08-Memory_Management_4_class.ppt
[os-fstruct]: /resources/OS/series2/Section11-File_Struct.ppt
[os-seg-page]: /resources/OS/series2/Segmented_PAGING.pdf

[soft-prev-1]: /resources/SOFTWARE/IT_301.pdf
[soft-prev-2]: /resources/SOFTWARE/IT301_S.pdf
[soft-class-notes]: /resources/SOFTWARE/series2/class_diagrams.docx
[soft-shop]: /resources/SOFTWARE/series2/class-example-online-shopping-domain.png
[soft-lib]: /resources/SOFTWARE/series2/library-management-system-7-638.jpg
[sof-syll]: /resources/SOFTWARE/IT301_Software_Architecture_and_Design_Patterns.pdf
[process-models]: /resources/SOFTWARE/series1/Process_models.pptx
[soft-design-principles]: /resources/SOFTWARE/series1/Software_design_principles_new.pptx
[chap-1]: /resources/SOFTWARE/series1/Chapter_01.pdf
[chap-3]: /resources/SOFTWARE/series1/Chapter_3_Software_Process_Model.ppt
[goal-soft]: /resources/SOFTWARE/series1/Goals_of_software_design.docx
[types-UML]: /resources/SOFTWARE/series1/Types_of_UML_Diagrams.pdf
[use-ex]: /resources/SOFTWARE/series1/usecase_example.docx
[use-bank]: /resources/SOFTWARE/series1/banking_usecase.jpg
[use-atm]: /resources/SOFTWARE/series1/atm_usecase.png
[activity-diagram]: /resources/SOFTWARE/series2/activity_diagrams.ppt
[act-shop-img1]: /resources/SOFTWARE/series2/act-diag-img1.jpeg
[act-shop-img2]: /resources/SOFTWARE/series2/act-diag-img2.jpeg
[sadp-state]: /resources/SOFTWARE/series2/6-States,_Actions,_&_Activities.pdf
[soft-arch-styles]: /resources/SOFTWARE/series2/sw_arch_styles_new.pptx
[soft-mvc]: /resources/SOFTWARE/series2/MVC.ppt
[sadp-interaction]: /resources/SOFTWARE/series2/Interaction_Diagrams.pptx
[sadp-deploy]: /resources/SOFTWARE/series2/deployment-diagram.pdf
[activity-diagram2]: /resources/SOFTWARE/series2/Activity_diagram_notes.pdf
[sadp-dp-1]: /resources/SOFTWARE/series2/4_Design_Principles_I.pdf
[sadp-dp-2]: /resources/SOFTWARE/series2/5_Design_Principles_II.pdf
[atam-sadp]: /resources/SOFTWARE/series2/IntroductionATAM.pdf
[sadp-atam]: /resources/SOFTWARE/series2/ATAM-.pdf

[net-syll]: /resources/NETWORKS/IT307_Computer_Networks.pdf
[net-prev-1]: /resources/NETWORKS/IT_307Semester-5.pdf
[net-prev-2]: /resources/NETWORKS/IT307_S.pdf

[toc-prev-1]: /resources/TOC/IT303._S5_Dec_17_Regular.pdf
[toc-prev-2]: /resources/TOC/IT303_S.pdf
[toc-syll]: /resources/TOC/IT303_Theory_of_Computation.pdf
[t-note]: /resources/TOC/series1/TOC_notes.doc

[cg-syll]: /resources/GRAPHICS/IT367_ComputerGraphics_&_Multimedia.pdf
[cg-prev]: /resources/GRAPHICS/IT_367_Computer_Graphics_Semester-5_Dec-17.pdf

[dblab-post-pdf]: /resources/DB-LAB/dblab.pdf
[dblab-post-sql]: /resources/DB-LAB/dblab.sql
[dblab-ques-pdf]: /resources/DB-LAB/DBLabQns3,4,5,6.pdf
[dblab-ques-sql]: /resources/DB-LAB/DBLabQns3,4,5,6.sql
[dblab-func-pdf]: /resources/DB-LAB/functions.pdf
[dblab-func-sql]: /resources/DB-LAB/functions.sql

[unix-syll]: /resources/UNIX/IT363_Unix_Shell_Programming.pdf
[unix-prev-1]: /resources/UNIX/Unix_Shell_Programming.pdf
[unix-prev-2]: /resources/UNIX/IT363_S.pdf
[unix-awk]: /resources/UNIX/awk.pptx
[unix-shell-jobs]: /resources/UNIX/shell-jobs.ppt

branch_name: refs/heads/gh-pages

gha_language: HTML