OpenLLM-France/wikimedia huggingface dataset:
# First Aid/Oxygen Administration
## Oxygen Administration
### Nasal Cannula

The nasal cannula is a thin tube with two small nozzles that protrude into the victim's nostrils. It can only provide oxygen at low flow rates: 2-6 liters per minute, delivering a concentration of 28-44%. Use of the nasal cannula at higher flow rates than 6 liters per minute can cause discomfort by drying the nasal passages and pain from the force of the oxygen.

### Bag-Valve-Mask

    See also: Bag-Valve-Mask
The task of administrating oxygen with bag-valve-mask (BVM) requires one hand to squeeze the bag and one to maintain a good seal with the mask. Thus, this task can advantageously be achieved by one rescuer, who will then keep their mind free and, being at the head of the victim, have a good view of the overall situation. The head of the victim can be secured between the knees of the BVM operator. The bag-valve-mask (BVM) is used for victims in critical condition who require pure oxygen. A reservoir bag is attached to a central cylindrical bag, attached to a valved mask that administers 100% concentration oxygen at 8-15LPM. The central bag is squeezed manually to ventilate the victim.

### Non-rebreathing Mask

The non-rebreathing mask (NRB) is utilized for patients with multiple trauma injuries, chronic airway limitation/chronic obstructive pulmonary diseases, smoke inhalation, and carbon monoxide poisoning, or any other patient that requires high-flow oxygen, but does not require breathing assistance. It has an attached reservoir bag where oxygen fills in between breaths, and a valve that largely prevents the inhalation of room or exhaled air. This allows the administration of high concentrations of oxygen, between 65-85%. This device is set to 10-15 lpm, or at least enough to keep the reservoir inflated between breaths. Due to the poor seal on a patient's face, it is exceedingly difficult to obtain anything approaching 100% oxygen with this device. While some patients with Chronic Obstructive Pulmonary Disease (COPD) rely on what is called hypoxic drive, high flow oxygen should never be withheld from COPD patients who require it.

### Pocket Mask

The pocket mask is a small device that can be carried on one's person. It is used for the same victims that the BVM is indicated for, but instead of delivering breaths by squeezing a reservoir, the first aider must actually exhale into the mask. Pocket masks normally have one-way valves built into them to protect against cross-contamination. Many masks also have an oxygen intake built-in, allowing for administration of 50-60% oxygen.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6
## 2...Nc6

This move is a side line. Black's main move is 2...d6. It also sets a trap.

## Theory table

| 3 | 4 | 5 | |
| d4? Qh4+ | g3 Qxd4 | | -/+ |
| Nf3 g5 | d4 g4 | Ng5 d6 | +/= |
| | | Ng1!? | +/= |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. Nf3
## 3.Nf3

This sound developing move wisely avoids d4? Qh4+ g3 Qxd4.

## Theory table

| 3 | 4 | 5 | |
| ... g5!? | d4 g4 | Ng5 d6 | +/= |
| ... d6 | exd6 Bxd6 | d4 Nf6 | +/= |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. Nf3/3...g5
## 3...g5!?

This is a committing and demented-looking move. But it is the a standard move in the From's Gambit. The point of 3...g5 to to play ...g4 and kick the f3-knight away, and to discourage kingside castling by White. However, it is certainly not without consequence.

## Theory Table

| 4 | 5 | |
| d4 g4 | Ng5 d6 | +/= |
| h3?! | | |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5
## From's Gambit Accepted

This wins a pawn, but creates more kingside weaknesses. Now white will have to be careful to not allow a quick knockout in the opening, after d6 exd6 Bxd6. For example: 4.Nc3?? Qh4+ g3 Qxg3+!! hxg3 Bxg3# is a slam dunk finish.
Practically taking the pawn is the best move, since Black gambits are rarely sound due to White's first move. That way, Black's compensation is minimized compared to White's gambits.
White is better, but he will defend for a long time and it is not easy. If White knows what he is doing, he should be better. At club level, it is popular as amateurs know less about the From's Gambit and there are many traps.
Black will typically plan to attack the weakened white kingside. He is threatening Qh4+ and a sacrifice on g3 followed by mate after d6 exd6 Bxd6.

## Theory table

| From's gambit | fxe5 d6 | exd6 Bxd6 | ∞ |
| From's Gambit | fxe5 Nc6 | Nf3 g5 | +/= |

## References

* 1 2 Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. Nf3/3...g5/4. d4/4...g4
## 4...g4

This move continues the plan of Black's 3...g5. He is kicking the f3-knight away. Houdini recommends the passive-looking Ng1 d6 e4!, giving back the pawn. After dxe5 d5 Nce7 Nc3 f5 (Otherwise white gets a bind on the f-file), Bg5 h6 Bh4 Bg7 Bb5+ Kf7 Bc4 Qd6 and both exf5 and Bb5 are good for white.

## Theory table

| 5 | 6 | 7 | |
| Ng5 d6 | e4 h6?! | Nxf7! Kxf7 | +/- |
| Ng1!? | | | +/- |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. Nf3/3...g5/4. d4/4...g4/5. Ng5
## 5.Ng5

This move is fine and sets a bunch of traps. d6, d5, and Bh6 have all been played
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. Nf3/3...g5/4. d4
## 4.d4

This is a common move in the From's Gambit for White, defending e5 and attacking g5 at the same time. 4.h3 was weakening, but also playable. However, it was not in the spirit of the From's Gambit.
Black can now continue his plan with 4...g4.

## Theory table

| 4 | 5 | |
| d4 g4 | Ng5 d6 | +/= |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. d4
## 3.d4?

This tries to hold on to e5, but it falls for a trap and gives Black the upper hand! In Lakdawala's database, it was played 11 times, with only 5 out of 11 people found the relatively easy to find Qh4+ g3 Qxd4 with a better pawn structure for black.

## Theory Table

| 3 | 4 | |
| Qh4+ | g3 Qxd4 | -/+ |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. d4/3...Qh4/4. g3
## 4.g3

This move is forced, as Kd2?? Qxd4+ is obviously horrible for white. Now, he will be left with a doubled e-pawn and a bad pawn structure.

## Theory table

| 4 | |
| ... Qxd4 | +/- |
# Chess Opening Theory/1. f4/1...e5/2. fxe5/2...Nc6/3. d4/3...Qh4
## 3...Qh4+

This simple move forks the king and the d4-pawn. Black will now regain his pawn with the advantage.

## Theory table

| 4 | |
| g3 Qxd4 | -/+ |

## References

* ↑ Lakdawala, Cyrus. Bird's Opening: Move by Move. Everyman Chess, 2015.
# Erlang Programming/Performance and Optimization
## Profiling

There are a number of profiling libraries available:
* cprof
* eprof
* fprof
Profiling of any kind has a runtime performance penalty - the reason for the different libraries above is their different trade-offs in terms of profiling precision and the performance penalty for using them.
# Erlang Programming/Parallel Programming
## Prime Sieve (parallel with linda type coordination)

Linda is a way to coordinate the actions of multiple processors. A tuplespace is created for the candidate primes to live. The sieve processes are created and send messages to the tuplespace to remove non-primes. The sieve processes also send messages to each others to remove the non-prime sieves.
How many processors can this program use? This program creates as many sieves as the square root of the numbers in the matrix (tuplespace).
If we are looking for the primes below 100 then there are about 10 parallel sieve processes. Actually, most of the sieve processes are halted and only (the number of prime numbers under the square root of Max) processes are left at the end. This allows an easy parallelism of 10 for 100 and 100 for 10000 with little modification.
In Erlang, it is not recommended that one use a huge number of atoms, so N should not get too large. We also might run out of processes or memory.
This program breaks one of the general rules of Erlang process management: do not use peer managers. Each of the sieve processes is a peer manager because each sieve may halt any other sieve. Rather, processes should be managed in a top-down tree structure. The peer management of the sieves causes some nasty timing issues. Timing is one reason why peers are usually a bad idea.
When the sieve for 2 ends, the list of primes is dumped. Erlang should give each process equal CPU time. When the slices are even, the sieve for 2 starts first and ends last. When some other sieve is starved for time, it may end after sieve 2 and the prime number dump will be too early, leaving some numbers divisible by 2 in the list of putative primes. Relative starvation of some process happens about 1 out of 10 times. Clearly the critical word should be: "tries". "Erlang TRIES to give each process equal time slices."
Does it hurt to have non-prime sieves running? We can use a 6-sieve. A 6-sieve is redundant because the 2-sieve and the 3-sieve remove all numbers that the 6-sieve would remove. By removing the 6-sieve and its non-prime sieve brothers we reduce the number of messages that the matrix must handle thereby speeding the final result.
# Erlang Programming/Pattern Matching

← Terms | Expressions →
Erlang uses powerful pattern-matching to bind variables to values. Pattern matching can be explicit, as when the = (pattern matching operator) is used, or implicit, as when a function call is processed and a function's actual arguments are matched with its formal parameters.

## Patterns

Patterns look the same as terms - they can be simple literals like atoms and numbers, compound like tuples and lists, or a mixture of both. They can also contain variables, which are alphanumeric strings that begin with a capital letter or underscore. A special "anonymous variable", _ (the underscore) is used when you don't care about the value to be matched, and won't be using it.
A pattern matches if it has the same "shape" as the term being matched, and atoms encountered are the same. For example, the following matches succeed:
* A = 1.
* 1 = 1.
* {ok, A} = {ok, 42}.
* [H|T] = [1, 2, 3].
Note that in the fourth example, the pipe (|) signifying the head and tail of the list as described in Terms.
These matches fail:
* 1 = 2.
* {ok, A} = {failure, "Don't know the question"}.
* [H|T] =.
In the case of the pattern-matching operator, a failure generates an error and the process exits. How this can be trapped and handled is covered in Errors.
Patterns are used to select which clause of a function will be executed (this is covered in Functions; which option to select in a case expression (Expressions); and which messages to retrieve from the mailbox (Processes).

### Variables

Erlang variables are single-assignment variables that do not have to be declared. They are written with a capital letter or underscore followed by an alphanumeric sequence. They are bound to values using the pattern matching mechanism. The Erlang compiler will produce an error if an unbound variable is used, and a warning if a bound variable is not used. Sometimes you might encounter a _Var variable. This variable is bound and does contain a value, however it suppresses compiler warnings regarding unused bound variables.

## Notes

* ↑ Since Erlang variables are immutable, consider examples like this to be standalone--even though the A is used twice, it's a different A each time!
# Erlang Programming/Processes
## Erlang Processes and Messages

Processes are easy to create and control in Erlang.
The program chain_hello.erl builds a chain of processes as long as you like. Each process creates one process then sends a message to it. The program creates a chain of N processes which each print out "hello world!<N>" (where <N> is some integer).
Processes send messages to and receive messages from one another. Messages are read with pattern matching. The messages are matched in a fifo (first in, first out) way.
Note 1: The order of the final output depends on process scheduling.
Note 2: Time flows downward (in each vertical line, see note 1).
This is a Process Message Diagram for the execution of: chain_hello:start(1).
Program listing for: chain_hello.erl
# Erlang Programming/Quick tips

One thing that can slow you down when you are getting started or trying to do some rapid prototyping is to export functions all the time. Rather, you can use the compiler directive. This makes programming erlang much more enjoyable, not to have to manually type:
everytime you add a function and would like to test it. Rather, you can use:
You can manually export only the things you need to when you are done with the program.
Another handy trick is to use
Rather than compile the latest version all the time.
or is it
?Module in code gives the current module name, which is super helpful when spawning.
Otherwise, you need to change the module name in every spawn every time you change the name of the module. If you would like to keep an eye on a process you can monitor it, after you have registered it.
A helpful utility function is rpc.
This helps keep synchronous commands between processes from getting answers from the wrong process. We force the identification of the process providing the answer, and sequential queuing should handle the rest.
# Erlang Programming/Records

Records in Erlang are syntactic sugar for tagged tuples. The functionality is provided by the preprocessor, not the compiler, so there are some interesting restrictions on how you use them and their support functions.

## Defining Records

The code above defines a record called myrecord with two elements: "first_element" and "second_element". From now on we can use the record syntax #myrecord.

## Equivalent to Tuples

Records are syntactic sugar for tuples.
The record we defined with two fields is equivalent to a tuple with a tag (the name of the record) and as many elements as the record has fields—two, in our case.
# Erlang Programming/Techniques of Recursion
## Techniques of Recursion
### Simple techniques
#### Assembly-Disassembly

Often we would like to build a list using a recursive function. Perhaps we would like to reverse a list. We start with a single-argument version (the public entry point function) and use it to call the double-argument version (private), where the extra argument contains the output we wish to build. We can take the head off of the input, [H|T], as we build up the output, Build. When input is empty, we are done.
Observe the nice way that strings are actually processed as lists of chars. Syntactic sugar changes strings into lists and back.
(Here we use the assembly-disassembly technique of recursion. Johnny-Five would not approve of this technique. [Reference to the 1986 movie "Short Circuit."])
Remember, we need to bracket H because it needs to be a list when we do list concatenation with the plus-plus, '++'. T is always a list in [H|T]. H may or may not be a list in [H|T]; either way we need to give it a bracket so it behaves properly.
Compile and run.
We can reverse a string, which is really a list. We can reverse a list of integers. We can reverse a list of lists. We can reverse a list of tuples. But we cannot reverse a tuple of lists, because the top level structure is not a list.
If we wanted to be slick, we could use a guard to check the type of the argument at the entry point, then if it is a tuple, change it to a list, execute the reverse, and then change it back to a tuple on the way out.
Please note that the example is purely educational, and in real applications you should avoid appending to the list one element at a time. The correct way to build a list is using the [Head|Tail] form. Often this will cause the list to be in reverse order. To remedy that we then use the lists:reverse built-in-function. See example
Compile and run the functions to compare.
The reason behind the speed difference is in the implementation of Erlang lists as linked lists.

## Exercises

1) Write a function t_reverse(T) that reverses a Tuple, T, of size 5. (i.e. {a,b,c,d,e})
2) Write a function r_reverse(L) that recursively reverses each sublist in a list of lists, L.
3) Write a function s_reverse(L) that recursively reverses only the sublists but not the top level in a list of lists.
4) Write a function n_reverse(L) that recursively reverses sublists only if they contain integers.
# French/Lessons/Dates

* Introduction
* The alphabet
* Greetings
* Formal speech
* Numbers
* Dates
* Telling time
Lessons · Vocabulary · Grammar · Appendices · Texts

## Vocabulary · Days · Les jours

* The days of the week are not capitalized in French.
* The calender starts on Monday, unlike the English Sunday.
* ^ On est quel jour aujourd'hui? is less formal but more common.
* Nous sommes... is not used with hier, aujourd’hui, or demain. C'était (past) or C'est (present/future) must be used accordingly.

## Vocabulary · Months · Les mois

* The months of the year are not capitalized in French.
On May 5, one would say "C'est le cinq mai." However, the first of the month uses "le premier" (the first): C'est le premier août (August 1).

## Dialogue · How old are you?

Marcel and Chantal are talking about how old they are. They are good friends.
* Chantal - Quel âge as-tu, Marcel ?
* Marcel - J'ai huit ans. Et toi ?
* Chantal - J'ai dix ans. Quel âge a-t-elle ?
* Marcel - Elle a six ans.
← Numbers ·  Introductory lessons  · Time →
Introduction · The alphabet · Greetings · Formal speech · Numbers · Dates · Telling time
Lessons :
Introductory · Level one · Level two · Level three · Level four
French :
Lessons · Vocabulary · Grammar · Appendices · Texts
# French/Lessons/Description

* People and things
* To be
* Description
* Family
* Recreation
* The house
* Weather
* Travel
* Art
* Science
Lessons · Vocabulary · Grammar · Appendices · Texts
    C'est un ouvrage intéressant.
and possibly understand:
    Cette personne-là est extrêmement polie.

## Dialogue

Mark is describing someone: 'Il est blond. Il est assez petit. Il est très intelligent. Il est sympa.'
George is describing someone: 'Elle est assez grosse. Elle est très amusante et assez patiente.'
Chantal is describing a group of her friends: 'Ils sont extrêmement amusants. Ils sont assez forts.'

## Grammar · Adjectives · Les adjectifs

Like articles, French adjectives match the nouns that they modify in gender and number.

### Regular formation

Most adjective changes occur in the following manner:
* Feminine: add an -e to the masculine form
    un garçon intéressant → une fille intéressante
    un ami amusant → une amie amusante
    un camion lent → une voiture lente
* Plural: add an -s to the singular form
    un garçon intéressant → des garçons intéressants
    une fille intéressante → des filles intéressantes

### Pronunciation

Generally, the final consonant is pronounced only when it comes before an -e. Most adjectives, such as those above, are affected by this rule.
* Masculine pronunciation:
    intéressant /ɛ̃.te.ʁɛ.sɑ̃/
    amusant /a.my.zɑ̃/
    lent /lɑ̃/
* Feminine pronunciation:
    intéressante /ɛ̃.te.ʁɛ.sɑ̃t/
    amusante /a.my.zɑ̃t/
    lente /lɑ̃t/
With plural adjectives, the -s ending is not pronounced, so the adjective will sound exactly the same as the singular form.

### Supplementary grammar · Exceptions and irregularities

Adjectives that end in e in the masculine form do not change in gender. When an adjective, such as gros, ends in -s, it does not change in the masculine plural form. Sometimes the final consonant is doubled in the feminine form.

## Grammar · Demonstrative adjectives

The adjectives ce, cet, and cette mean this or that, and the adjective ces means these or those.
The adjective used must agree in gender and number with the noun it modifies:
To be more precise or to avoid ambiguity, -ci$^{here}$ or -là$^{there}$ can be inserted after the noun:
    cet homme-ci$^{thisman}$
    cet homme-là$^{thatman}$

### Examples
## Dialogue

Natasha is describing a friend: 'Elle est très forte, elle est grande, et elle est intelligente.'
Marc is describing someone: 'Il est handicapé; il est sourd et muet.'
Jules is describing a group of his friends: 'Ils sont très polis, attachants et sincères.'

## Exercises

(Highlight or hover over a line to show the answer.)
(Highlight or hover over a line to show the answer.)
← To be ·  Level one lessons  · Family →
People and things · To be · Description · Family · Recreation · The house · Weather · Travel · Art · Science
Lessons :
Introductory · Level one · Level two · Level three · Level four
French :
Lessons · Vocabulary · Grammar · Appendices · Texts
# French/Lessons/Current events

* Vacations
* Work
* Health
* Money
* Youth
* Adolescence
* Historical France
* Revolutionary France
* Modern France
* Current events
Lessons · Vocabulary · Grammar · Appendices · Texts

## Grammar · Future perfect

The future perfect tense, or the futur antérieur, is used to say that before an event occurs, something else will have occurred by that time. Phrases constructed in the future perfect tense mean will have …ed in both French and English.

### Formation

The future perfect is a perfect tense, and therefore consists of an auxiliary verb and a past participle. The auxiliary verb, avoir or être, is conjugated in the future tense. All rules that apply to the passé composé and other perfect tenses, such as certain verbs using être as an auxiliary verb, apply to the future perfect as well.

### Examples
## Exercises

* Combien de tours l'élection du président comporte-t-elle ?
* Y a-t-il des candidats qui ne sont pas soutenus par un parti ?
* Qui a gagné l'élection de 2002 au second tour ? Qui a perdu ?
← Modern France ·  Level three lessons
Vacations · Work · Health · Money · Youth · Adolescence · Historical France · Revolutionary France · Modern France · Current events
Lessons :
Introductory · Level one · Level two · Level three · Level four
French :
Lessons · Vocabulary · Grammar · Appendices · Texts