From 4e4196bd41f8b0c95a4e9df65a24b8124540fb4d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 16:38:31 +0200
Subject: [PATCH 1/8] Add strict types for all php files

---
 exercises/practice/accumulate/.meta/example.php    |  2 ++
 exercises/practice/accumulate/Accumulate.php       |  2 ++
 exercises/practice/accumulate/AccumulateTest.php   |  2 ++
 exercises/practice/acronym/.meta/example.php       |  2 ++
 exercises/practice/acronym/Acronym.php             |  2 ++
 exercises/practice/acronym/AcronymTest.php         |  2 ++
 exercises/practice/affine-cipher/.meta/example.php |  2 ++
 exercises/practice/affine-cipher/AffineCipher.php  |  2 ++
 .../practice/affine-cipher/AffineCipherTest.php    |  2 ++
 exercises/practice/all-your-base/.meta/example.php |  2 ++
 exercises/practice/all-your-base/AllYourBase.php   |  2 ++
 .../practice/all-your-base/AllYourBaseTest.php     |  2 ++
 exercises/practice/allergies/.meta/example.php     |  2 ++
 exercises/practice/allergies/Allergies.php         |  2 ++
 exercises/practice/allergies/AllergiesTest.php     |  2 ++
 exercises/practice/anagram/.meta/example.php       |  2 ++
 exercises/practice/anagram/Anagram.php             |  2 ++
 exercises/practice/anagram/AnagramTest.php         |  2 ++
 .../practice/armstrong-numbers/.meta/example.php   |  2 ++
 .../armstrong-numbers/ArmstrongNumbers.php         |  2 ++
 .../armstrong-numbers/ArmstrongNumbersTest.php     |  2 ++
 exercises/practice/atbash-cipher/.meta/example.php |  2 ++
 exercises/practice/atbash-cipher/AtbashCipher.php  |  2 ++
 .../practice/atbash-cipher/AtbashCipherTest.php    |  2 ++
 exercises/practice/beer-song/.meta/example.php     |  2 ++
 exercises/practice/beer-song/BeerSong.php          |  2 ++
 exercises/practice/beer-song/BeerSongTest.php      |  2 ++
 exercises/practice/binary-search/.meta/example.php |  2 ++
 exercises/practice/binary-search/BinarySearch.php  |  2 ++
 .../practice/binary-search/BinarySearchTest.php    |  2 ++
 exercises/practice/binary/.meta/example.php        |  2 ++
 exercises/practice/binary/Binary.php               |  2 ++
 exercises/practice/binary/BinaryTest.php           |  2 ++
 exercises/practice/bob/.meta/example.php           |  2 ++
 exercises/practice/bob/Bob.php                     |  2 ++
 exercises/practice/bob/BobTest.php                 |  2 ++
 exercises/practice/book-store/.meta/example.php    |  2 ++
 exercises/practice/book-store/BookStore.php        |  2 ++
 exercises/practice/book-store/BookStoreTest.php    |  2 ++
 exercises/practice/bowling/.meta/example.php       |  2 ++
 exercises/practice/bowling/Bowling.php             |  2 ++
 exercises/practice/bowling/BowlingTest.php         |  2 ++
 exercises/practice/change/.meta/example.php        |  2 ++
 exercises/practice/change/Change.php               |  2 ++
 exercises/practice/change/ChangeTest.php           |  2 ++
 exercises/practice/clock/.meta/example.php         |  2 ++
 exercises/practice/clock/Clock.php                 |  2 ++
 exercises/practice/clock/ClockTest.php             |  2 ++
 .../practice/collatz-conjecture/.meta/example.php  |  2 ++
 .../collatz-conjecture/CollatzConjecture.php       |  2 ++
 .../collatz-conjecture/CollatzConjectureTest.php   |  2 ++
 exercises/practice/connect/.meta/example.php       |  2 ++
 exercises/practice/connect/Connect.php             |  2 ++
 exercises/practice/connect/ConnectTest.php         |  2 ++
 exercises/practice/crypto-square/.meta/example.php |  2 ++
 exercises/practice/crypto-square/CryptoSquare.php  |  2 ++
 .../practice/crypto-square/CryptoSquareTest.php    |  2 ++
 exercises/practice/diamond/.meta/example.php       |  2 ++
 exercises/practice/diamond/Diamond.php             |  2 ++
 exercises/practice/diamond/DiamondTest.php         |  2 ++
 .../difference-of-squares/.meta/example.php        |  2 ++
 .../difference-of-squares/DifferenceOfSquares.php  |  2 ++
 .../DifferenceOfSquaresTest.php                    |  2 ++
 exercises/practice/etl/.meta/example.php           |  2 ++
 exercises/practice/etl/Etl.php                     |  2 ++
 exercises/practice/etl/EtlTest.php                 |  2 ++
 exercises/practice/flatten-array/.meta/example.php |  2 ++
 exercises/practice/flatten-array/FlattenArray.php  |  2 ++
 .../practice/flatten-array/FlattenArrayTest.php    |  2 ++
 exercises/practice/gigasecond/.meta/example.php    |  2 ++
 exercises/practice/gigasecond/Gigasecond.php       |  2 ++
 exercises/practice/gigasecond/GigasecondTest.php   |  2 ++
 exercises/practice/grade-school/.meta/example.php  |  2 ++
 exercises/practice/grade-school/GradeSchool.php    |  2 ++
 .../practice/grade-school/GradeSchoolTest.php      |  2 ++
 exercises/practice/grains/.meta/example.php        |  2 ++
 exercises/practice/grains/Grains.php               |  2 ++
 exercises/practice/grains/GrainsTest.php           |  2 ++
 exercises/practice/hamming/.meta/example.php       |  2 ++
 exercises/practice/hamming/Hamming.php             |  2 ++
 exercises/practice/hamming/HammingTest.php         |  2 ++
 exercises/practice/hello-world/.meta/example.php   |  2 ++
 exercises/practice/hello-world/HelloWorld.php      |  2 ++
 exercises/practice/hello-world/HelloWorldTest.php  |  2 ++
 exercises/practice/isogram/.meta/example.php       |  2 ++
 exercises/practice/isogram/Isogram.php             |  2 ++
 exercises/practice/isogram/IsogramTest.php         |  2 ++
 .../largest-series-product/.meta/example.php       |  2 ++
 .../LargestSeriesProduct.php                       |  2 ++
 .../LargestSeriesProductTest.php                   | 14 ++++++++------
 exercises/practice/leap/.meta/example.php          |  2 ++
 exercises/practice/leap/Leap.php                   |  2 ++
 exercises/practice/leap/LeapTest.php               |  2 ++
 exercises/practice/luhn/.meta/example.php          |  2 ++
 exercises/practice/luhn/Luhn.php                   |  2 ++
 exercises/practice/luhn/LuhnTest.php               |  2 ++
 exercises/practice/markdown/.meta/example.php      |  2 ++
 exercises/practice/markdown/Markdown.php           |  2 ++
 exercises/practice/markdown/MarkdownTest.php       |  2 ++
 .../practice/matching-brackets/.meta/example.php   |  2 ++
 .../matching-brackets/MatchingBrackets.php         |  2 ++
 .../matching-brackets/MatchingBracketsTest.php     |  2 ++
 exercises/practice/meetup/.meta/example.php        |  2 ++
 exercises/practice/meetup/Meetup.php               |  2 ++
 exercises/practice/minesweeper/.meta/example.php   |  2 ++
 exercises/practice/minesweeper/Minesweeper.php     |  2 ++
 exercises/practice/minesweeper/MinesweeperTest.php |  2 ++
 exercises/practice/nth-prime/.meta/example.php     |  2 ++
 exercises/practice/nth-prime/NthPrime.php          |  2 ++
 exercises/practice/nth-prime/NthPrimeTest.php      |  2 ++
 .../practice/nucleotide-count/.meta/example.php    |  2 ++
 .../practice/nucleotide-count/NucleotideCount.php  |  2 ++
 .../nucleotide-count/NucleotideCountTest.php       |  2 ++
 exercises/practice/ocr-numbers/.meta/example.php   |  2 ++
 exercises/practice/ocr-numbers/OcrNumbers.php      |  2 ++
 .../practice/ordinal-number/.meta/example.php      |  2 ++
 .../practice/ordinal-number/OrdinalNumber.php      |  2 ++
 .../practice/ordinal-number/OrdinalNumberTest.php  |  2 ++
 .../palindrome-products/PalindromeProducts.php     |  2 ++
 .../palindrome-products/PalindromeProductsTest.php |  2 ++
 exercises/practice/pangram/.meta/example.php       |  2 ++
 exercises/practice/pangram/Pangram.php             |  2 ++
 exercises/practice/pangram/PangramTest.php         |  2 ++
 .../practice/pascals-triangle/.meta/example.php    |  2 ++
 .../practice/pascals-triangle/PascalsTriangle.php  |  2 ++
 .../pascals-triangle/PascalsTriangleTest.php       |  2 ++
 .../practice/perfect-numbers/.meta/example.php     |  2 ++
 .../practice/perfect-numbers/PerfectNumbers.php    |  2 ++
 .../perfect-numbers/PerfectNumbersTest.php         |  2 ++
 exercises/practice/phone-number/.meta/example.php  |  2 ++
 exercises/practice/phone-number/PhoneNumber.php    |  2 ++
 .../practice/phone-number/PhoneNumberTest.php      |  2 ++
 exercises/practice/pig-latin/.meta/example.php     |  2 ++
 exercises/practice/pig-latin/PigLatin.php          |  2 ++
 exercises/practice/pig-latin/PigLatinTest.php      |  2 ++
 exercises/practice/prime-factors/.meta/example.php |  2 ++
 exercises/practice/prime-factors/PrimeFactors.php  |  2 ++
 .../practice/prime-factors/PrimeFactorsTest.php    |  2 ++
 exercises/practice/queen-attack/.meta/example.php  |  2 ++
 exercises/practice/queen-attack/QueenAttack.php    |  2 ++
 .../practice/queen-attack/QueenAttackTest.php      |  2 ++
 .../practice/rail-fence-cipher/.meta/example.php   |  4 +++-
 .../practice/rail-fence-cipher/RailFenceCipher.php |  2 ++
 .../rail-fence-cipher/RailFenceCipherTest.php      |  2 ++
 exercises/practice/raindrops/.meta/example.php     |  2 ++
 exercises/practice/raindrops/Raindrops.php         |  2 ++
 exercises/practice/raindrops/RaindropsTest.php     |  2 ++
 .../practice/rna-transcription/.meta/example.php   |  2 ++
 .../rna-transcription/RnaTranscription.php         |  2 ++
 exercises/practice/robot-name/.meta/example.php    |  2 ++
 exercises/practice/robot-name/RobotName.php        |  2 ++
 exercises/practice/robot-name/RobotNameTest.php    |  2 ++
 .../practice/robot-simulator/.meta/example.php     |  2 ++
 .../practice/robot-simulator/RobotSimulator.php    |  2 ++
 .../robot-simulator/RobotSimulatorTest.php         |  2 ++
 .../practice/roman-numerals/.meta/example.php      |  2 ++
 .../practice/roman-numerals/RomanNumerals.php      |  2 ++
 .../practice/roman-numerals/RomanNumeralsTest.php  |  2 ++
 .../practice/run-length-encoding/.meta/example.php |  2 ++
 .../run-length-encoding/RunLengthEncoding.php      |  2 ++
 .../run-length-encoding/RunLengthEncodingTest.php  |  2 ++
 .../practice/scrabble-score/.meta/example.php      |  2 ++
 .../practice/scrabble-score/ScrabbleScore.php      |  2 ++
 .../practice/scrabble-score/ScrabbleScoreTest.php  |  2 ++
 exercises/practice/series/.meta/example.php        |  2 ++
 exercises/practice/series/Series.php               |  2 ++
 exercises/practice/series/SeriesTest.php           |  2 ++
 exercises/practice/sieve/.meta/example.php         |  2 ++
 exercises/practice/sieve/Sieve.php                 |  2 ++
 exercises/practice/sieve/SieveTest.php             |  2 ++
 exercises/practice/space-age/.meta/example.php     |  2 ++
 exercises/practice/space-age/SpaceAge.php          |  2 ++
 exercises/practice/space-age/SpaceAgeTest.php      |  2 ++
 .../practice/sum-of-multiples/.meta/example.php    |  2 ++
 .../practice/sum-of-multiples/SumOfMultiples.php   |  2 ++
 .../sum-of-multiples/SumOfMultiplesTest.php        |  2 ++
 exercises/practice/transpose/.meta/example.php     |  2 ++
 exercises/practice/transpose/Transpose.php         |  2 ++
 exercises/practice/transpose/TransposeTest.php     |  2 ++
 exercises/practice/triangle/.meta/example.php      |  2 ++
 exercises/practice/triangle/Triangle.php           |  2 ++
 exercises/practice/triangle/TriangleTest.php       |  2 ++
 exercises/practice/trinary/.meta/example.php       |  2 ++
 exercises/practice/trinary/Trinary.php             |  2 ++
 exercises/practice/trinary/TrinaryTest.php         |  2 ++
 exercises/practice/two-fer/.meta/example.php       |  2 ++
 exercises/practice/two-fer/TwoFer.php              |  2 ++
 exercises/practice/two-fer/TwoFerTest.php          |  2 ++
 .../variable-length-quantity/.meta/example.php     |  2 ++
 .../VariableLengthQuantity.php                     |  2 ++
 .../VariableLengthQuantityTest.php                 |  2 ++
 exercises/practice/word-count/.meta/example.php    |  2 ++
 exercises/practice/word-count/WordCount.php        |  2 ++
 exercises/practice/word-count/WordCountTest.php    |  2 ++
 exercises/practice/wordy/.meta/example.php         |  2 ++
 exercises/practice/wordy/Wordy.php                 |  2 ++
 exercises/practice/wordy/WordyTest.php             |  2 ++
 197 files changed, 401 insertions(+), 7 deletions(-)

diff --git a/exercises/practice/accumulate/.meta/example.php b/exercises/practice/accumulate/.meta/example.php
index b1b571bb..0f48fbfb 100644
--- a/exercises/practice/accumulate/.meta/example.php
+++ b/exercises/practice/accumulate/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Given the input array and operation returns an array
  * containing the result of applying that operation
diff --git a/exercises/practice/accumulate/Accumulate.php b/exercises/practice/accumulate/Accumulate.php
index 82822607..1eb96ea8 100644
--- a/exercises/practice/accumulate/Accumulate.php
+++ b/exercises/practice/accumulate/Accumulate.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function accumulate(array $input, callable $accumulator): array
 {
     throw new \BadFunctionCallException("Implement the accumulate function");
diff --git a/exercises/practice/accumulate/AccumulateTest.php b/exercises/practice/accumulate/AccumulateTest.php
index 389d9f25..4102aaa7 100644
--- a/exercises/practice/accumulate/AccumulateTest.php
+++ b/exercises/practice/accumulate/AccumulateTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class AccumulateTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/acronym/.meta/example.php b/exercises/practice/acronym/.meta/example.php
index e237ae42..f7b4970e 100644
--- a/exercises/practice/acronym/.meta/example.php
+++ b/exercises/practice/acronym/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Abbreviates a phrase.
  *
diff --git a/exercises/practice/acronym/Acronym.php b/exercises/practice/acronym/Acronym.php
index 85af5977..f7b0bf9f 100644
--- a/exercises/practice/acronym/Acronym.php
+++ b/exercises/practice/acronym/Acronym.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function acronym(string $text): string
 {
     throw new \BadFunctionCallException("Implement the acronym function");
diff --git a/exercises/practice/acronym/AcronymTest.php b/exercises/practice/acronym/AcronymTest.php
index 563e42f9..38972b13 100644
--- a/exercises/practice/acronym/AcronymTest.php
+++ b/exercises/practice/acronym/AcronymTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class AcronymTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/affine-cipher/.meta/example.php b/exercises/practice/affine-cipher/.meta/example.php
index 947fbcd4..5cb352c9 100644
--- a/exercises/practice/affine-cipher/.meta/example.php
+++ b/exercises/practice/affine-cipher/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode($text, $a, $b)
 {
     $alphabet = range('a', 'z');
diff --git a/exercises/practice/affine-cipher/AffineCipher.php b/exercises/practice/affine-cipher/AffineCipher.php
index 356c4145..2e0fd494 100644
--- a/exercises/practice/affine-cipher/AffineCipher.php
+++ b/exercises/practice/affine-cipher/AffineCipher.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode(string $text, int $num1, int $num2): string
 {
     throw new \BadFunctionCallException("Implement the encode function");
diff --git a/exercises/practice/affine-cipher/AffineCipherTest.php b/exercises/practice/affine-cipher/AffineCipherTest.php
index 652a1888..82592e84 100644
--- a/exercises/practice/affine-cipher/AffineCipherTest.php
+++ b/exercises/practice/affine-cipher/AffineCipherTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * The test are divided into two groups:
  *
diff --git a/exercises/practice/all-your-base/.meta/example.php b/exercises/practice/all-your-base/.meta/example.php
index 85fcca16..cdc9e131 100644
--- a/exercises/practice/all-your-base/.meta/example.php
+++ b/exercises/practice/all-your-base/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function rebase(int $fromBase, array $digits, int $toBase)
 {
     if (empty($digits) || $digits[0] == 0 || $fromBase <= 1 || $toBase <= 1) {
diff --git a/exercises/practice/all-your-base/AllYourBase.php b/exercises/practice/all-your-base/AllYourBase.php
index 49b23f80..3be20c68 100644
--- a/exercises/practice/all-your-base/AllYourBase.php
+++ b/exercises/practice/all-your-base/AllYourBase.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function rebase(int $number, array $sequence, int $base)
 {
     throw new \BadFunctionCallException("Implement the rebase function");
diff --git a/exercises/practice/all-your-base/AllYourBaseTest.php b/exercises/practice/all-your-base/AllYourBaseTest.php
index da375d37..eeae5b82 100644
--- a/exercises/practice/all-your-base/AllYourBaseTest.php
+++ b/exercises/practice/all-your-base/AllYourBaseTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * These tests are adapted from the canonical data in the
  * `problem-specifications` repository.
diff --git a/exercises/practice/allergies/.meta/example.php b/exercises/practice/allergies/.meta/example.php
index bfe2ffb9..97c7f3d0 100644
--- a/exercises/practice/allergies/.meta/example.php
+++ b/exercises/practice/allergies/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Allergies
 {
     private $score;
diff --git a/exercises/practice/allergies/Allergies.php b/exercises/practice/allergies/Allergies.php
index a4fec532..1cf036bf 100644
--- a/exercises/practice/allergies/Allergies.php
+++ b/exercises/practice/allergies/Allergies.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Allergies
 {
     public function __construct(int $score)
diff --git a/exercises/practice/allergies/AllergiesTest.php b/exercises/practice/allergies/AllergiesTest.php
index d06ccdec..ce19101a 100644
--- a/exercises/practice/allergies/AllergiesTest.php
+++ b/exercises/practice/allergies/AllergiesTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class AllergiesTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/anagram/.meta/example.php b/exercises/practice/anagram/.meta/example.php
index 74d6a2d8..a6a97f5f 100644
--- a/exercises/practice/anagram/.meta/example.php
+++ b/exercises/practice/anagram/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function detectAnagrams($anagram, array $possibleMatches)
 {
     $matches = [];
diff --git a/exercises/practice/anagram/Anagram.php b/exercises/practice/anagram/Anagram.php
index 8f70b4eb..f7e185df 100644
--- a/exercises/practice/anagram/Anagram.php
+++ b/exercises/practice/anagram/Anagram.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function detectAnagrams(string $word, array $anagrams): array
 {
     throw new \BadFunctionCallException("Implement the detectAnagrams function");
diff --git a/exercises/practice/anagram/AnagramTest.php b/exercises/practice/anagram/AnagramTest.php
index 8419d65b..823ab267 100644
--- a/exercises/practice/anagram/AnagramTest.php
+++ b/exercises/practice/anagram/AnagramTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class AnagramTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/armstrong-numbers/.meta/example.php b/exercises/practice/armstrong-numbers/.meta/example.php
index 1131bd27..b091bcea 100644
--- a/exercises/practice/armstrong-numbers/.meta/example.php
+++ b/exercises/practice/armstrong-numbers/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isArmstrongNumber(int $number): bool
 {
     $total = 0;
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
index c000a9ad..affb3747 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isArmstrongNumber(int $number): bool
 {
     throw new \BadFunctionCallException("Implement the isArmstrongNumber function");
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
index 6efb2393..19baf1e0 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class ArmstrongNumbersTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/atbash-cipher/.meta/example.php b/exercises/practice/atbash-cipher/.meta/example.php
index f69eed56..2b850cf6 100644
--- a/exercises/practice/atbash-cipher/.meta/example.php
+++ b/exercises/practice/atbash-cipher/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode($string)
 {
     $a_z = range('a', 'z');
diff --git a/exercises/practice/atbash-cipher/AtbashCipher.php b/exercises/practice/atbash-cipher/AtbashCipher.php
index cc8894bc..767d2d68 100644
--- a/exercises/practice/atbash-cipher/AtbashCipher.php
+++ b/exercises/practice/atbash-cipher/AtbashCipher.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode(string $text): string
 {
     throw new \BadFunctionCallException("Implement the encode function");
diff --git a/exercises/practice/atbash-cipher/AtbashCipherTest.php b/exercises/practice/atbash-cipher/AtbashCipherTest.php
index e89f714d..dac714b8 100644
--- a/exercises/practice/atbash-cipher/AtbashCipherTest.php
+++ b/exercises/practice/atbash-cipher/AtbashCipherTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class AtbashCipherTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/beer-song/.meta/example.php b/exercises/practice/beer-song/.meta/example.php
index 84573356..6342c2e7 100644
--- a/exercises/practice/beer-song/.meta/example.php
+++ b/exercises/practice/beer-song/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BeerSong
 {
     public function verse($number): string
diff --git a/exercises/practice/beer-song/BeerSong.php b/exercises/practice/beer-song/BeerSong.php
index ab114cd0..42a25770 100644
--- a/exercises/practice/beer-song/BeerSong.php
+++ b/exercises/practice/beer-song/BeerSong.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BeerSong
 {
     public function verse(int $number): string
diff --git a/exercises/practice/beer-song/BeerSongTest.php b/exercises/practice/beer-song/BeerSongTest.php
index bef1eea8..e0711360 100644
--- a/exercises/practice/beer-song/BeerSongTest.php
+++ b/exercises/practice/beer-song/BeerSongTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BeerSongTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/binary-search/.meta/example.php b/exercises/practice/binary-search/.meta/example.php
index c1da0060..79cf0b31 100644
--- a/exercises/practice/binary-search/.meta/example.php
+++ b/exercises/practice/binary-search/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function find($needle, $haystack)
 {
     $left = 0;
diff --git a/exercises/practice/binary-search/BinarySearch.php b/exercises/practice/binary-search/BinarySearch.php
index 7466dbb5..294b965f 100644
--- a/exercises/practice/binary-search/BinarySearch.php
+++ b/exercises/practice/binary-search/BinarySearch.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function find(int $needle, array $haystack): int
 {
     throw new \BadFunctionCallException("Implement the find function");
diff --git a/exercises/practice/binary-search/BinarySearchTest.php b/exercises/practice/binary-search/BinarySearchTest.php
index 207d360d..73482289 100644
--- a/exercises/practice/binary-search/BinarySearchTest.php
+++ b/exercises/practice/binary-search/BinarySearchTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BinarySearchTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/binary/.meta/example.php b/exercises/practice/binary/.meta/example.php
index 057cd94b..2b2a3a6e 100644
--- a/exercises/practice/binary/.meta/example.php
+++ b/exercises/practice/binary/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Converts binary value to a decimal.
  *
diff --git a/exercises/practice/binary/Binary.php b/exercises/practice/binary/Binary.php
index 6c7bd395..46558fea 100644
--- a/exercises/practice/binary/Binary.php
+++ b/exercises/practice/binary/Binary.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function parse_binary(string $binary): int
 {
     throw new \BadFunctionCallException("Implement the parse_binary function");
diff --git a/exercises/practice/binary/BinaryTest.php b/exercises/practice/binary/BinaryTest.php
index 12a6cc04..53435a24 100644
--- a/exercises/practice/binary/BinaryTest.php
+++ b/exercises/practice/binary/BinaryTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BinaryTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/bob/.meta/example.php b/exercises/practice/bob/.meta/example.php
index cafcfacc..50217a45 100644
--- a/exercises/practice/bob/.meta/example.php
+++ b/exercises/practice/bob/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Bob
 {
     /**
diff --git a/exercises/practice/bob/Bob.php b/exercises/practice/bob/Bob.php
index 58218350..7e237b21 100644
--- a/exercises/practice/bob/Bob.php
+++ b/exercises/practice/bob/Bob.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Bob
 {
     public function respondTo(string $str): string
diff --git a/exercises/practice/bob/BobTest.php b/exercises/practice/bob/BobTest.php
index 1bd84fd1..7450dde4 100644
--- a/exercises/practice/bob/BobTest.php
+++ b/exercises/practice/bob/BobTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class BobTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/book-store/.meta/example.php b/exercises/practice/book-store/.meta/example.php
index 33305194..2f451373 100644
--- a/exercises/practice/book-store/.meta/example.php
+++ b/exercises/practice/book-store/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function total($items)
 {
     return calculate($items, 0);
diff --git a/exercises/practice/book-store/BookStore.php b/exercises/practice/book-store/BookStore.php
index ba9157fb..113a3c84 100644
--- a/exercises/practice/book-store/BookStore.php
+++ b/exercises/practice/book-store/BookStore.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function total(array $items): float
 {
     throw new \BadFunctionCallException("Implement the total function");
diff --git a/exercises/practice/book-store/BookStoreTest.php b/exercises/practice/book-store/BookStoreTest.php
index 8d1d47ed..873ed7a4 100644
--- a/exercises/practice/book-store/BookStoreTest.php
+++ b/exercises/practice/book-store/BookStoreTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Calculate lowest price for shopping basket only
  * containing books from a single series. There is no
diff --git a/exercises/practice/bowling/.meta/example.php b/exercises/practice/bowling/.meta/example.php
index c723be2e..803b74e4 100644
--- a/exercises/practice/bowling/.meta/example.php
+++ b/exercises/practice/bowling/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Translated from original source:
  * http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata
diff --git a/exercises/practice/bowling/Bowling.php b/exercises/practice/bowling/Bowling.php
index ac6512cc..87b75937 100644
--- a/exercises/practice/bowling/Bowling.php
+++ b/exercises/practice/bowling/Bowling.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Game
 {
     public function score(): int
diff --git a/exercises/practice/bowling/BowlingTest.php b/exercises/practice/bowling/BowlingTest.php
index 494f9e9e..965e812b 100644
--- a/exercises/practice/bowling/BowlingTest.php
+++ b/exercises/practice/bowling/BowlingTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Translated from original source:
  * http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata
diff --git a/exercises/practice/change/.meta/example.php b/exercises/practice/change/.meta/example.php
index a847248b..35cdcce4 100644
--- a/exercises/practice/change/.meta/example.php
+++ b/exercises/practice/change/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 // adapted from the python example
 function findFewestCoins(array $coins, int $total_change): array
 {
diff --git a/exercises/practice/change/Change.php b/exercises/practice/change/Change.php
index c6f19da3..6612208b 100644
--- a/exercises/practice/change/Change.php
+++ b/exercises/practice/change/Change.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function findFewestCoins(array $coins, int $amount): array
 {
     throw new \BadFunctionCallException("Implement the findFewestCoins function");
diff --git a/exercises/practice/change/ChangeTest.php b/exercises/practice/change/ChangeTest.php
index a749394c..38498fbd 100644
--- a/exercises/practice/change/ChangeTest.php
+++ b/exercises/practice/change/ChangeTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class ChangeTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/clock/.meta/example.php b/exercises/practice/clock/.meta/example.php
index 3bced89a..09d2a3c3 100644
--- a/exercises/practice/clock/.meta/example.php
+++ b/exercises/practice/clock/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Clock
 {
     /**
diff --git a/exercises/practice/clock/Clock.php b/exercises/practice/clock/Clock.php
index 26aa6b67..7b861530 100644
--- a/exercises/practice/clock/Clock.php
+++ b/exercises/practice/clock/Clock.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Clock
 {
     public function __toString(): string
diff --git a/exercises/practice/clock/ClockTest.php b/exercises/practice/clock/ClockTest.php
index 8a7f4a4f..6d4da74d 100644
--- a/exercises/practice/clock/ClockTest.php
+++ b/exercises/practice/clock/ClockTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class ClockTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/collatz-conjecture/.meta/example.php b/exercises/practice/collatz-conjecture/.meta/example.php
index 8b79c154..bcce0527 100644
--- a/exercises/practice/collatz-conjecture/.meta/example.php
+++ b/exercises/practice/collatz-conjecture/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function steps($number)
 {
     $stepCount = 0;
diff --git a/exercises/practice/collatz-conjecture/CollatzConjecture.php b/exercises/practice/collatz-conjecture/CollatzConjecture.php
index accd1d1b..4b1d00ed 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjecture.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjecture.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function steps(int $number): int
 {
     throw new \BadFunctionCallException("Implement the steps function");
diff --git a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
index 9c9386f0..d8e6a89c 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class CollatzConjectureTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/connect/.meta/example.php b/exercises/practice/connect/.meta/example.php
index a0e70bb6..28d53331 100644
--- a/exercises/practice/connect/.meta/example.php
+++ b/exercises/practice/connect/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 const NOTHING = 0;
 const WHITE = 1;
 const BLACK = 2;
diff --git a/exercises/practice/connect/Connect.php b/exercises/practice/connect/Connect.php
index ef75ab61..5001c793 100644
--- a/exercises/practice/connect/Connect.php
+++ b/exercises/practice/connect/Connect.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function resultFor(array $lines)
 {
     throw new \BadFunctionCallException("Implement the resultFor method");
diff --git a/exercises/practice/connect/ConnectTest.php b/exercises/practice/connect/ConnectTest.php
index 00b90aa3..e3a8ee1e 100644
--- a/exercises/practice/connect/ConnectTest.php
+++ b/exercises/practice/connect/ConnectTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class ConnectTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/crypto-square/.meta/example.php b/exercises/practice/crypto-square/.meta/example.php
index 61da62f1..98cedcf5 100644
--- a/exercises/practice/crypto-square/.meta/example.php
+++ b/exercises/practice/crypto-square/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function crypto_square($plaintext)
 {
     $normalized = preg_replace('/\W*/', '', strtolower($plaintext));
diff --git a/exercises/practice/crypto-square/CryptoSquare.php b/exercises/practice/crypto-square/CryptoSquare.php
index 70573b6b..f431fea5 100644
--- a/exercises/practice/crypto-square/CryptoSquare.php
+++ b/exercises/practice/crypto-square/CryptoSquare.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function crypto_square(string $plaintext): string
 {
     throw new \BadFunctionCallException("Implement the crypto_square function");
diff --git a/exercises/practice/crypto-square/CryptoSquareTest.php b/exercises/practice/crypto-square/CryptoSquareTest.php
index 0a1afae3..e089536b 100644
--- a/exercises/practice/crypto-square/CryptoSquareTest.php
+++ b/exercises/practice/crypto-square/CryptoSquareTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class CryptoSquareTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/diamond/.meta/example.php b/exercises/practice/diamond/.meta/example.php
index 1834b585..87348afe 100644
--- a/exercises/practice/diamond/.meta/example.php
+++ b/exercises/practice/diamond/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function diamond($limit)
 {
     $alphabet = range('A', $limit);
diff --git a/exercises/practice/diamond/Diamond.php b/exercises/practice/diamond/Diamond.php
index c272cfc7..127b243e 100644
--- a/exercises/practice/diamond/Diamond.php
+++ b/exercises/practice/diamond/Diamond.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function diamond(string $letter): array
 {
     throw new \BadFunctionCallException("Implement the diamond function");
diff --git a/exercises/practice/diamond/DiamondTest.php b/exercises/practice/diamond/DiamondTest.php
index 92efe3c5..17c17020 100644
--- a/exercises/practice/diamond/DiamondTest.php
+++ b/exercises/practice/diamond/DiamondTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class DiamondTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/difference-of-squares/.meta/example.php b/exercises/practice/difference-of-squares/.meta/example.php
index e323e9e7..b05919fe 100644
--- a/exercises/practice/difference-of-squares/.meta/example.php
+++ b/exercises/practice/difference-of-squares/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function squareOfSum($max)
 {
     $sum = 0;
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquares.php b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
index fd706e7a..29a7f2bc 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquares.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function squareOfSum(int $max): int
 {
     throw new \BadFunctionCallException("Implement the squareOfSum function");
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
index 729cb011..f2bbc0ef 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class DifferenceOfSquaresTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/etl/.meta/example.php b/exercises/practice/etl/.meta/example.php
index 77dcc9ad..fe137af5 100644
--- a/exercises/practice/etl/.meta/example.php
+++ b/exercises/practice/etl/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function transform($old)
 {
     $new = [];
diff --git a/exercises/practice/etl/Etl.php b/exercises/practice/etl/Etl.php
index ede11a8e..6cda93d8 100644
--- a/exercises/practice/etl/Etl.php
+++ b/exercises/practice/etl/Etl.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function transform(array $input): array
 {
     throw new \BadFunctionCallException("Implement the transform function");
diff --git a/exercises/practice/etl/EtlTest.php b/exercises/practice/etl/EtlTest.php
index 330bb06b..70976129 100644
--- a/exercises/practice/etl/EtlTest.php
+++ b/exercises/practice/etl/EtlTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class EtlTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/flatten-array/.meta/example.php b/exercises/practice/flatten-array/.meta/example.php
index 3ba5ebeb..02aa7751 100644
--- a/exercises/practice/flatten-array/.meta/example.php
+++ b/exercises/practice/flatten-array/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function flatten($array = [])
 {
     $return = [];
diff --git a/exercises/practice/flatten-array/FlattenArray.php b/exercises/practice/flatten-array/FlattenArray.php
index 24ef945b..3b956c21 100644
--- a/exercises/practice/flatten-array/FlattenArray.php
+++ b/exercises/practice/flatten-array/FlattenArray.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function flatten(array $input): array
 {
     throw new \BadFunctionCallException("Implement the flatten function");
diff --git a/exercises/practice/flatten-array/FlattenArrayTest.php b/exercises/practice/flatten-array/FlattenArrayTest.php
index 6466814f..b2c9ca72 100644
--- a/exercises/practice/flatten-array/FlattenArrayTest.php
+++ b/exercises/practice/flatten-array/FlattenArrayTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class FlattenArrayTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/gigasecond/.meta/example.php b/exercises/practice/gigasecond/.meta/example.php
index 9cd7205e..2605fd82 100644
--- a/exercises/practice/gigasecond/.meta/example.php
+++ b/exercises/practice/gigasecond/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function from(DateTimeImmutable $from): DateTimeImmutable
 {
     $interval = new DateInterval('PT1000000000S');
diff --git a/exercises/practice/gigasecond/Gigasecond.php b/exercises/practice/gigasecond/Gigasecond.php
index 4b5a736f..b063058b 100644
--- a/exercises/practice/gigasecond/Gigasecond.php
+++ b/exercises/practice/gigasecond/Gigasecond.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function from(DateTimeImmutable $date): DateTimeImmutable
 {
     throw new \BadFunctionCallException("Implement the from function");
diff --git a/exercises/practice/gigasecond/GigasecondTest.php b/exercises/practice/gigasecond/GigasecondTest.php
index 1c5175c3..27323ac0 100644
--- a/exercises/practice/gigasecond/GigasecondTest.php
+++ b/exercises/practice/gigasecond/GigasecondTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class GigasecondTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/grade-school/.meta/example.php b/exercises/practice/grade-school/.meta/example.php
index 9834371b..2cc5b463 100644
--- a/exercises/practice/grade-school/.meta/example.php
+++ b/exercises/practice/grade-school/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class School
 {
     private $students = [];
diff --git a/exercises/practice/grade-school/GradeSchool.php b/exercises/practice/grade-school/GradeSchool.php
index 122ba24a..8adde9d6 100644
--- a/exercises/practice/grade-school/GradeSchool.php
+++ b/exercises/practice/grade-school/GradeSchool.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class School
 {
     public function add(string $name, int $grade): void
diff --git a/exercises/practice/grade-school/GradeSchoolTest.php b/exercises/practice/grade-school/GradeSchoolTest.php
index 449a7221..da50f748 100644
--- a/exercises/practice/grade-school/GradeSchoolTest.php
+++ b/exercises/practice/grade-school/GradeSchoolTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 use PHPUnit\Framework\TestCase;
 
 class GradeSchoolTest extends TestCase
diff --git a/exercises/practice/grains/.meta/example.php b/exercises/practice/grains/.meta/example.php
index 6bab142d..926c8466 100644
--- a/exercises/practice/grains/.meta/example.php
+++ b/exercises/practice/grains/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  *
 Here is the simplest solution. But King hates floats.
diff --git a/exercises/practice/grains/Grains.php b/exercises/practice/grains/Grains.php
index 4c3e73a9..c7f46793 100644
--- a/exercises/practice/grains/Grains.php
+++ b/exercises/practice/grains/Grains.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function square(int $number): string
 {
     throw new \BadFunctionCallException("Implement the square function");
diff --git a/exercises/practice/grains/GrainsTest.php b/exercises/practice/grains/GrainsTest.php
index 758c69e2..ab0c41da 100644
--- a/exercises/practice/grains/GrainsTest.php
+++ b/exercises/practice/grains/GrainsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class GrainsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/hamming/.meta/example.php b/exercises/practice/hamming/.meta/example.php
index 012fe839..3aebbb0e 100644
--- a/exercises/practice/hamming/.meta/example.php
+++ b/exercises/practice/hamming/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * @param string $a
  * @param string $b
diff --git a/exercises/practice/hamming/Hamming.php b/exercises/practice/hamming/Hamming.php
index f2f0f708..1673019c 100644
--- a/exercises/practice/hamming/Hamming.php
+++ b/exercises/practice/hamming/Hamming.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function distance(string $strandA, string $strandB): int
 {
     throw new \BadFunctionCallException("Implement the distance function");
diff --git a/exercises/practice/hamming/HammingTest.php b/exercises/practice/hamming/HammingTest.php
index b05a3a66..48c603ab 100644
--- a/exercises/practice/hamming/HammingTest.php
+++ b/exercises/practice/hamming/HammingTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class HammingTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/hello-world/.meta/example.php b/exercises/practice/hello-world/.meta/example.php
index 80d86e86..29eab547 100644
--- a/exercises/practice/hello-world/.meta/example.php
+++ b/exercises/practice/hello-world/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function helloWorld($name = 'World')
 {
     return "Hello, $name!";
diff --git a/exercises/practice/hello-world/HelloWorld.php b/exercises/practice/hello-world/HelloWorld.php
index 6f8ce238..f8cc37f0 100644
--- a/exercises/practice/hello-world/HelloWorld.php
+++ b/exercises/practice/hello-world/HelloWorld.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 //
 // This is only a SKELETON file for the "Hello World" exercise.
 // It's been provided as a convenience to get you started writing code faster.
diff --git a/exercises/practice/hello-world/HelloWorldTest.php b/exercises/practice/hello-world/HelloWorldTest.php
index 96ee8a30..35f51af5 100644
--- a/exercises/practice/hello-world/HelloWorldTest.php
+++ b/exercises/practice/hello-world/HelloWorldTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class HelloWorldTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/isogram/.meta/example.php b/exercises/practice/isogram/.meta/example.php
index 74dbe67c..1f9aec0f 100644
--- a/exercises/practice/isogram/.meta/example.php
+++ b/exercises/practice/isogram/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isIsogram($string)
 {
     $string = str_replace(['-', ' '], '', mb_strtolower($string));
diff --git a/exercises/practice/isogram/Isogram.php b/exercises/practice/isogram/Isogram.php
index 2815d0c1..6e33091c 100644
--- a/exercises/practice/isogram/Isogram.php
+++ b/exercises/practice/isogram/Isogram.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isogram(string $word): bool
 {
     throw new \BadFunctionCallException("Implement the isogram function");
diff --git a/exercises/practice/isogram/IsogramTest.php b/exercises/practice/isogram/IsogramTest.php
index d24e6ea9..316895eb 100644
--- a/exercises/practice/isogram/IsogramTest.php
+++ b/exercises/practice/isogram/IsogramTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class IsogramTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/largest-series-product/.meta/example.php b/exercises/practice/largest-series-product/.meta/example.php
index 15387158..7cf24696 100644
--- a/exercises/practice/largest-series-product/.meta/example.php
+++ b/exercises/practice/largest-series-product/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Series
 {
     /**
diff --git a/exercises/practice/largest-series-product/LargestSeriesProduct.php b/exercises/practice/largest-series-product/LargestSeriesProduct.php
index a7a008fc..354266b4 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProduct.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProduct.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Series
 {
     public function largestProduct(int $span): int
diff --git a/exercises/practice/largest-series-product/LargestSeriesProductTest.php b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
index 36d62a50..627dadba 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProductTest.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class LargestSeriesProductTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
@@ -22,25 +24,25 @@ public function testCanFindTheLargestProductOf2WithNumbersInOrder(): void
 
     public function testCanFindTheLargestProductOf2(): void
     {
-        $series = new Series(576802143);
+        $series = new Series("576802143");
         $this->assertEquals(48, $series->largestProduct(2));
     }
 
     public function testFindsTheLargestProductIfSpanEqualsLength(): void
     {
-        $series = new Series(29);
+        $series = new Series("29");
         $this->assertEquals(18, $series->largestProduct(2));
     }
 
     public function testCanFindTheLargestProductOf3WithNumbersInOrder(): void
     {
-        $series = new Series(123456789);
+        $series = new Series("123456789");
         $this->assertEquals(504, $series->largestProduct(3));
     }
 
     public function testCanFindTheLargestProductOf3(): void
     {
-        $series = new Series(1027839564);
+        $series = new Series("1027839564");
         $this->assertEquals(270, $series->largestProduct(3));
     }
 
@@ -82,7 +84,7 @@ public function testReportsZeroIfTheOnlyDigitsAreZero(): void
 
     public function testReportsZeroIfAllSpansIncludeZero(): void
     {
-        $series = new Series(99099);
+        $series = new Series("99099");
         $this->assertEquals(0, $series->largestProduct(3));
     }
 
@@ -90,7 +92,7 @@ public function testRejectsSpanLongerThanStringLength(): void
     {
         $this->expectException(InvalidArgumentException::class);
 
-        $series = new Series(123);
+        $series = new Series("123");
         $series->largestProduct(4);
     }
 
diff --git a/exercises/practice/leap/.meta/example.php b/exercises/practice/leap/.meta/example.php
index 8a75a315..66fdd6e3 100644
--- a/exercises/practice/leap/.meta/example.php
+++ b/exercises/practice/leap/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * @return bool
  */
diff --git a/exercises/practice/leap/Leap.php b/exercises/practice/leap/Leap.php
index 88c6c9de..621c3149 100644
--- a/exercises/practice/leap/Leap.php
+++ b/exercises/practice/leap/Leap.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isLeap(int $year): bool
 {
     throw new \BadFunctionCallException("Implement the isLeap function");
diff --git a/exercises/practice/leap/LeapTest.php b/exercises/practice/leap/LeapTest.php
index 37e7746e..7c7f622c 100644
--- a/exercises/practice/leap/LeapTest.php
+++ b/exercises/practice/leap/LeapTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class LeapTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/luhn/.meta/example.php b/exercises/practice/luhn/.meta/example.php
index db27c805..40ba888e 100644
--- a/exercises/practice/luhn/.meta/example.php
+++ b/exercises/practice/luhn/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isValid($candidate)
 {
     $sanitizedCandidate = str_replace(" ", "", $candidate) ;
diff --git a/exercises/practice/luhn/Luhn.php b/exercises/practice/luhn/Luhn.php
index 0de5fac5..41867cbe 100644
--- a/exercises/practice/luhn/Luhn.php
+++ b/exercises/practice/luhn/Luhn.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isValid(string $number): bool
 {
     throw new \BadFunctionCallException("Implement the isValid function");
diff --git a/exercises/practice/luhn/LuhnTest.php b/exercises/practice/luhn/LuhnTest.php
index 420fb428..4acc639a 100644
--- a/exercises/practice/luhn/LuhnTest.php
+++ b/exercises/practice/luhn/LuhnTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class LuhnTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/markdown/.meta/example.php b/exercises/practice/markdown/.meta/example.php
index 5c3ef0fb..b1f1fdd2 100644
--- a/exercises/practice/markdown/.meta/example.php
+++ b/exercises/practice/markdown/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function parseMarkdown($markdown)
 {
     $lines = explode("\n", $markdown);
diff --git a/exercises/practice/markdown/Markdown.php b/exercises/practice/markdown/Markdown.php
index 92a0748f..a0ab8173 100644
--- a/exercises/practice/markdown/Markdown.php
+++ b/exercises/practice/markdown/Markdown.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function parseMarkdown($markdown)
 {
     $lines = explode("\n", $markdown);
diff --git a/exercises/practice/markdown/MarkdownTest.php b/exercises/practice/markdown/MarkdownTest.php
index 832a18e2..8c39caa9 100644
--- a/exercises/practice/markdown/MarkdownTest.php
+++ b/exercises/practice/markdown/MarkdownTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class MarkdownTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/matching-brackets/.meta/example.php b/exercises/practice/matching-brackets/.meta/example.php
index 61bd4dff..4f5eb59d 100644
--- a/exercises/practice/matching-brackets/.meta/example.php
+++ b/exercises/practice/matching-brackets/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function brackets_match(string $input): bool
 {
     $characters = str_split($input);
diff --git a/exercises/practice/matching-brackets/MatchingBrackets.php b/exercises/practice/matching-brackets/MatchingBrackets.php
index 564776d1..3c0490e6 100644
--- a/exercises/practice/matching-brackets/MatchingBrackets.php
+++ b/exercises/practice/matching-brackets/MatchingBrackets.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function brackets_match(string $input): bool
 {
     throw new \BadFunctionCallException("Implement the brackets_match function");
diff --git a/exercises/practice/matching-brackets/MatchingBracketsTest.php b/exercises/practice/matching-brackets/MatchingBracketsTest.php
index 9043ff6c..ec8ae9be 100644
--- a/exercises/practice/matching-brackets/MatchingBracketsTest.php
+++ b/exercises/practice/matching-brackets/MatchingBracketsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class MatchingBracketsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/meetup/.meta/example.php b/exercises/practice/meetup/.meta/example.php
index b0f0a9ee..f44574d8 100644
--- a/exercises/practice/meetup/.meta/example.php
+++ b/exercises/practice/meetup/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function meetup_day($year, $month, $which, $weekday)
 {
     $monthName = DateTimeImmutable::createFromFormat("!m", $month)->format('F');
diff --git a/exercises/practice/meetup/Meetup.php b/exercises/practice/meetup/Meetup.php
index 08d6194a..3457c466 100644
--- a/exercises/practice/meetup/Meetup.php
+++ b/exercises/practice/meetup/Meetup.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function meetup_day(int $year, int $month, string $which, string $weekday): DateTimeImmutable
 {
     throw new \BadFunctionCallException("Implement the meetup_day function");
diff --git a/exercises/practice/minesweeper/.meta/example.php b/exercises/practice/minesweeper/.meta/example.php
index dcd05c33..07414f57 100644
--- a/exercises/practice/minesweeper/.meta/example.php
+++ b/exercises/practice/minesweeper/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function solve($minesweeperBoard)
 {
     $minesweeperBoard = makeBoardFromString($minesweeperBoard);
diff --git a/exercises/practice/minesweeper/Minesweeper.php b/exercises/practice/minesweeper/Minesweeper.php
index 09aaf360..74c323d4 100644
--- a/exercises/practice/minesweeper/Minesweeper.php
+++ b/exercises/practice/minesweeper/Minesweeper.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function solve(string $minesweeperBoard): string
 {
     throw new \BadFunctionCallException("Implement the solve function");
diff --git a/exercises/practice/minesweeper/MinesweeperTest.php b/exercises/practice/minesweeper/MinesweeperTest.php
index 8306a25a..4a3dd549 100644
--- a/exercises/practice/minesweeper/MinesweeperTest.php
+++ b/exercises/practice/minesweeper/MinesweeperTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class MinesweeperTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/nth-prime/.meta/example.php b/exercises/practice/nth-prime/.meta/example.php
index 43cbd2c1..5b31af6f 100644
--- a/exercises/practice/nth-prime/.meta/example.php
+++ b/exercises/practice/nth-prime/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function prime($count)
 {
     if ($count < 1) {
diff --git a/exercises/practice/nth-prime/NthPrime.php b/exercises/practice/nth-prime/NthPrime.php
index c1a92fb4..1a26c360 100644
--- a/exercises/practice/nth-prime/NthPrime.php
+++ b/exercises/practice/nth-prime/NthPrime.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function prime(int $number)
 {
     throw new \BadFunctionCallException("Implement the prime function");
diff --git a/exercises/practice/nth-prime/NthPrimeTest.php b/exercises/practice/nth-prime/NthPrimeTest.php
index 5c616cf6..722cf92d 100644
--- a/exercises/practice/nth-prime/NthPrimeTest.php
+++ b/exercises/practice/nth-prime/NthPrimeTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class NthPrimeTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/nucleotide-count/.meta/example.php b/exercises/practice/nucleotide-count/.meta/example.php
index 33815bf2..494a44ea 100644
--- a/exercises/practice/nucleotide-count/.meta/example.php
+++ b/exercises/practice/nucleotide-count/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function nucleotideCount($dna)
 {
     $nucleotides = [];
diff --git a/exercises/practice/nucleotide-count/NucleotideCount.php b/exercises/practice/nucleotide-count/NucleotideCount.php
index 736e884f..cf952273 100644
--- a/exercises/practice/nucleotide-count/NucleotideCount.php
+++ b/exercises/practice/nucleotide-count/NucleotideCount.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function nucleotideCount(string $input): array
 {
     throw new \BadFunctionCallException("Implement the nucleotideCount function");
diff --git a/exercises/practice/nucleotide-count/NucleotideCountTest.php b/exercises/practice/nucleotide-count/NucleotideCountTest.php
index 54f1632a..ef84d286 100644
--- a/exercises/practice/nucleotide-count/NucleotideCountTest.php
+++ b/exercises/practice/nucleotide-count/NucleotideCountTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class NucleotideCountTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/ocr-numbers/.meta/example.php b/exercises/practice/ocr-numbers/.meta/example.php
index b57b3845..8e6e6193 100644
--- a/exercises/practice/ocr-numbers/.meta/example.php
+++ b/exercises/practice/ocr-numbers/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function recognize($ocr)
 {
     return (new OcrBlock($ocr))->recognize();
diff --git a/exercises/practice/ocr-numbers/OcrNumbers.php b/exercises/practice/ocr-numbers/OcrNumbers.php
index 3068f415..6bc59bac 100644
--- a/exercises/practice/ocr-numbers/OcrNumbers.php
+++ b/exercises/practice/ocr-numbers/OcrNumbers.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function recognize(array $input): string
 {
     throw new \BadFunctionCallException("Implement the recognize function");
diff --git a/exercises/practice/ordinal-number/.meta/example.php b/exercises/practice/ordinal-number/.meta/example.php
index 5d422e16..2b60c128 100644
--- a/exercises/practice/ordinal-number/.meta/example.php
+++ b/exercises/practice/ordinal-number/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toOrdinal(int $number): string
 {
     if (0 === $number) {
diff --git a/exercises/practice/ordinal-number/OrdinalNumber.php b/exercises/practice/ordinal-number/OrdinalNumber.php
index b5bfc558..84a29d57 100644
--- a/exercises/practice/ordinal-number/OrdinalNumber.php
+++ b/exercises/practice/ordinal-number/OrdinalNumber.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toOrdinal(int $number): string
 {
     throw new \BadFunctionCallException("Implement the toOrdinal function");
diff --git a/exercises/practice/ordinal-number/OrdinalNumberTest.php b/exercises/practice/ordinal-number/OrdinalNumberTest.php
index 4b6000ce..2f6447b6 100644
--- a/exercises/practice/ordinal-number/OrdinalNumberTest.php
+++ b/exercises/practice/ordinal-number/OrdinalNumberTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class OrdinalNumberTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/palindrome-products/PalindromeProducts.php b/exercises/practice/palindrome-products/PalindromeProducts.php
index f28d7e76..e141cd55 100644
--- a/exercises/practice/palindrome-products/PalindromeProducts.php
+++ b/exercises/practice/palindrome-products/PalindromeProducts.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function smallest(int $min, int $max): array
 {
     throw new \BadFunctionCallException("Implement the smallest function");
diff --git a/exercises/practice/palindrome-products/PalindromeProductsTest.php b/exercises/practice/palindrome-products/PalindromeProductsTest.php
index c259ae71..2629d841 100644
--- a/exercises/practice/palindrome-products/PalindromeProductsTest.php
+++ b/exercises/practice/palindrome-products/PalindromeProductsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PalindromeProductsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/pangram/.meta/example.php b/exercises/practice/pangram/.meta/example.php
index 4965f2ee..319c6b9d 100644
--- a/exercises/practice/pangram/.meta/example.php
+++ b/exercises/practice/pangram/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isPangram($string)
 {
     $string = str_replace(['-', ' '], '', mb_strtolower($string));
diff --git a/exercises/practice/pangram/Pangram.php b/exercises/practice/pangram/Pangram.php
index a2cf4267..ff2a60f6 100644
--- a/exercises/practice/pangram/Pangram.php
+++ b/exercises/practice/pangram/Pangram.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function isPangram(string $string): bool
 {
     throw new \BadFunctionCallException("Implement the isPangram function");
diff --git a/exercises/practice/pangram/PangramTest.php b/exercises/practice/pangram/PangramTest.php
index cb881b08..ea1ab227 100644
--- a/exercises/practice/pangram/PangramTest.php
+++ b/exercises/practice/pangram/PangramTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PangramTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/pascals-triangle/.meta/example.php b/exercises/practice/pascals-triangle/.meta/example.php
index 137b8b12..da7c2825 100644
--- a/exercises/practice/pascals-triangle/.meta/example.php
+++ b/exercises/practice/pascals-triangle/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function pascalsTriangleRows($rowCount)
 {
     if ($rowCount < 0 || $rowCount === null) {
diff --git a/exercises/practice/pascals-triangle/PascalsTriangle.php b/exercises/practice/pascals-triangle/PascalsTriangle.php
index 08c87f63..62a4266d 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangle.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangle.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function pascalsTriangleRows(int $rowCount)
 {
     throw new \BadFunctionCallException("Implement the pascalsTriangleRows function");
diff --git a/exercises/practice/pascals-triangle/PascalsTriangleTest.php b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
index e95a7144..8af62b88 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangleTest.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PascalsTriangleTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/perfect-numbers/.meta/example.php b/exercises/practice/perfect-numbers/.meta/example.php
index 7cb4a6d2..4556f648 100644
--- a/exercises/practice/perfect-numbers/.meta/example.php
+++ b/exercises/practice/perfect-numbers/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function getClassification($number)
 {
     if ($number <= 0) {
diff --git a/exercises/practice/perfect-numbers/PerfectNumbers.php b/exercises/practice/perfect-numbers/PerfectNumbers.php
index 90d30753..b30baeac 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbers.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbers.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function getClassification(int $number): string
 {
     throw new \BadFunctionCallException("Implement the getClassification function");
diff --git a/exercises/practice/perfect-numbers/PerfectNumbersTest.php b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
index 66f2b8da..9a11f736 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbersTest.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PerfectNumbersTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/phone-number/.meta/example.php b/exercises/practice/phone-number/.meta/example.php
index 9d7792e7..c7dbc536 100644
--- a/exercises/practice/phone-number/.meta/example.php
+++ b/exercises/practice/phone-number/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PhoneNumber
 {
     private $number;
diff --git a/exercises/practice/phone-number/PhoneNumber.php b/exercises/practice/phone-number/PhoneNumber.php
index ec0382bb..c3ff1bc0 100644
--- a/exercises/practice/phone-number/PhoneNumber.php
+++ b/exercises/practice/phone-number/PhoneNumber.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PhoneNumber
 {
     public function number(): string
diff --git a/exercises/practice/phone-number/PhoneNumberTest.php b/exercises/practice/phone-number/PhoneNumberTest.php
index 49ba870d..e0bac93f 100644
--- a/exercises/practice/phone-number/PhoneNumberTest.php
+++ b/exercises/practice/phone-number/PhoneNumberTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PhoneNumberTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/pig-latin/.meta/example.php b/exercises/practice/pig-latin/.meta/example.php
index a1ca5d3a..32e73112 100644
--- a/exercises/practice/pig-latin/.meta/example.php
+++ b/exercises/practice/pig-latin/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Translates a string into Pig Latin
  *
diff --git a/exercises/practice/pig-latin/PigLatin.php b/exercises/practice/pig-latin/PigLatin.php
index aa14d132..e7f1e08d 100644
--- a/exercises/practice/pig-latin/PigLatin.php
+++ b/exercises/practice/pig-latin/PigLatin.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function translate(string $text): string
 {
     throw new \BadFunctionCallException("Implement the translate function");
diff --git a/exercises/practice/pig-latin/PigLatinTest.php b/exercises/practice/pig-latin/PigLatinTest.php
index 4562b4da..2acca732 100644
--- a/exercises/practice/pig-latin/PigLatinTest.php
+++ b/exercises/practice/pig-latin/PigLatinTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PigLatinTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/prime-factors/.meta/example.php b/exercises/practice/prime-factors/.meta/example.php
index f50ab313..90198824 100644
--- a/exercises/practice/prime-factors/.meta/example.php
+++ b/exercises/practice/prime-factors/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function factors($n)
 {
     $factorList = [];
diff --git a/exercises/practice/prime-factors/PrimeFactors.php b/exercises/practice/prime-factors/PrimeFactors.php
index e4f15cd3..157b9ffa 100644
--- a/exercises/practice/prime-factors/PrimeFactors.php
+++ b/exercises/practice/prime-factors/PrimeFactors.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function factors(int $number): array
 {
     throw new \BadFunctionCallException("Implement the factors function");
diff --git a/exercises/practice/prime-factors/PrimeFactorsTest.php b/exercises/practice/prime-factors/PrimeFactorsTest.php
index 23c0811a..3e36b54a 100644
--- a/exercises/practice/prime-factors/PrimeFactorsTest.php
+++ b/exercises/practice/prime-factors/PrimeFactorsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class PrimeFactorsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/queen-attack/.meta/example.php b/exercises/practice/queen-attack/.meta/example.php
index 2a471b2f..9ebf1680 100644
--- a/exercises/practice/queen-attack/.meta/example.php
+++ b/exercises/practice/queen-attack/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Check if the queen is placed on a valid square.
  *
diff --git a/exercises/practice/queen-attack/QueenAttack.php b/exercises/practice/queen-attack/QueenAttack.php
index cee6e874..0df82d15 100644
--- a/exercises/practice/queen-attack/QueenAttack.php
+++ b/exercises/practice/queen-attack/QueenAttack.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function placeQueen(int $xCoordinate, int $yCoordinate): bool
 {
     throw new \BadFunctionCallException("Implement the placeQueen function");
diff --git a/exercises/practice/queen-attack/QueenAttackTest.php b/exercises/practice/queen-attack/QueenAttackTest.php
index 24de5d6b..e45f148c 100644
--- a/exercises/practice/queen-attack/QueenAttackTest.php
+++ b/exercises/practice/queen-attack/QueenAttackTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class QueenAttackTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/rail-fence-cipher/.meta/example.php b/exercises/practice/rail-fence-cipher/.meta/example.php
index e61c6637..59b31b8c 100644
--- a/exercises/practice/rail-fence-cipher/.meta/example.php
+++ b/exercises/practice/rail-fence-cipher/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode($plainMessage, $rails)
 {
     $cipherMessage = [];
@@ -24,7 +26,7 @@ function decode($cipherMessage, $rails)
     $position = ($rails * 2) - 2;
     $textLength = strlen($cipherMessage);
 
-    $minLength = floor($textLength / $position);
+    $minLength = (int) floor($textLength / $position);
     $balance = $textLength % $position;
     $lengths = [];
     $strings = [];
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipher.php b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
index 54320faf..5e7d9792 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipher.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode(string $plainMessage, int $rails): string
 {
     throw new \BadFunctionCallException("Implement the encode function");
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
index 136515d7..773e5964 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RailFenceCipherTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/raindrops/.meta/example.php b/exercises/practice/raindrops/.meta/example.php
index e875a447..35cc7b45 100644
--- a/exercises/practice/raindrops/.meta/example.php
+++ b/exercises/practice/raindrops/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function raindrops($num)
 {
     $sound =
diff --git a/exercises/practice/raindrops/Raindrops.php b/exercises/practice/raindrops/Raindrops.php
index b501a91e..8ae5a187 100644
--- a/exercises/practice/raindrops/Raindrops.php
+++ b/exercises/practice/raindrops/Raindrops.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function raindrops(int $number): string
 {
     throw new \BadFunctionCallException("Implement the raindrops function");
diff --git a/exercises/practice/raindrops/RaindropsTest.php b/exercises/practice/raindrops/RaindropsTest.php
index b5dd1333..9f1a0804 100644
--- a/exercises/practice/raindrops/RaindropsTest.php
+++ b/exercises/practice/raindrops/RaindropsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RaindropsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/rna-transcription/.meta/example.php b/exercises/practice/rna-transcription/.meta/example.php
index b9be888c..3f29623f 100644
--- a/exercises/practice/rna-transcription/.meta/example.php
+++ b/exercises/practice/rna-transcription/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toRna($strand)
 {
     return strtr($strand, 'CGTA', 'GCAU');
diff --git a/exercises/practice/rna-transcription/RnaTranscription.php b/exercises/practice/rna-transcription/RnaTranscription.php
index db2f72ac..de76cccf 100644
--- a/exercises/practice/rna-transcription/RnaTranscription.php
+++ b/exercises/practice/rna-transcription/RnaTranscription.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toRna(string $dna): string
 {
     throw new \BadFunctionCallException("Implement the toRna function");
diff --git a/exercises/practice/robot-name/.meta/example.php b/exercises/practice/robot-name/.meta/example.php
index bfa76c77..1839f132 100644
--- a/exercises/practice/robot-name/.meta/example.php
+++ b/exercises/practice/robot-name/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Robot
 {
     private $name;
diff --git a/exercises/practice/robot-name/RobotName.php b/exercises/practice/robot-name/RobotName.php
index 797e8a9f..72a64768 100644
--- a/exercises/practice/robot-name/RobotName.php
+++ b/exercises/practice/robot-name/RobotName.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Robot
 {
     public function getName(): string
diff --git a/exercises/practice/robot-name/RobotNameTest.php b/exercises/practice/robot-name/RobotNameTest.php
index af4bbea7..83ab4fb5 100644
--- a/exercises/practice/robot-name/RobotNameTest.php
+++ b/exercises/practice/robot-name/RobotNameTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RobotNameTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/robot-simulator/.meta/example.php b/exercises/practice/robot-simulator/.meta/example.php
index a69a6d98..3fa032ab 100644
--- a/exercises/practice/robot-simulator/.meta/example.php
+++ b/exercises/practice/robot-simulator/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Robot
 {
     public const DIRECTION_NORTH = 'north';
diff --git a/exercises/practice/robot-simulator/RobotSimulator.php b/exercises/practice/robot-simulator/RobotSimulator.php
index f6c4f585..c878a25c 100644
--- a/exercises/practice/robot-simulator/RobotSimulator.php
+++ b/exercises/practice/robot-simulator/RobotSimulator.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Robot
 {
     /**
diff --git a/exercises/practice/robot-simulator/RobotSimulatorTest.php b/exercises/practice/robot-simulator/RobotSimulatorTest.php
index 35473628..f8f43a5a 100644
--- a/exercises/practice/robot-simulator/RobotSimulatorTest.php
+++ b/exercises/practice/robot-simulator/RobotSimulatorTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RobotSimulatorTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/roman-numerals/.meta/example.php b/exercises/practice/roman-numerals/.meta/example.php
index f90ac6c8..5335bf92 100644
--- a/exercises/practice/roman-numerals/.meta/example.php
+++ b/exercises/practice/roman-numerals/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toRoman($number)
 {
     $mapping = [
diff --git a/exercises/practice/roman-numerals/RomanNumerals.php b/exercises/practice/roman-numerals/RomanNumerals.php
index 131ffeaf..598bd7bb 100644
--- a/exercises/practice/roman-numerals/RomanNumerals.php
+++ b/exercises/practice/roman-numerals/RomanNumerals.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toRoman(int $number): string
 {
     throw new \BadFunctionCallException("Implement the toRoman function");
diff --git a/exercises/practice/roman-numerals/RomanNumeralsTest.php b/exercises/practice/roman-numerals/RomanNumeralsTest.php
index 96e1a090..f68e037d 100644
--- a/exercises/practice/roman-numerals/RomanNumeralsTest.php
+++ b/exercises/practice/roman-numerals/RomanNumeralsTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RomanNumeralsTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/run-length-encoding/.meta/example.php b/exercises/practice/run-length-encoding/.meta/example.php
index a3befcd1..2c0b7e8c 100644
--- a/exercises/practice/run-length-encoding/.meta/example.php
+++ b/exercises/practice/run-length-encoding/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * @param string $input
  * @return string
diff --git a/exercises/practice/run-length-encoding/RunLengthEncoding.php b/exercises/practice/run-length-encoding/RunLengthEncoding.php
index e0c82eea..2a8559b8 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncoding.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncoding.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function encode(string $input): string
 {
     throw new \BadFunctionCallException("Implement the encode function");
diff --git a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
index d1fed69a..98ea0abd 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RunLengthEncodingTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/scrabble-score/.meta/example.php b/exercises/practice/scrabble-score/.meta/example.php
index f3e1f41a..9df33e2e 100644
--- a/exercises/practice/scrabble-score/.meta/example.php
+++ b/exercises/practice/scrabble-score/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function score($word)
 {
     if (strlen($word) === 0 || $word === ' ') {
diff --git a/exercises/practice/scrabble-score/ScrabbleScore.php b/exercises/practice/scrabble-score/ScrabbleScore.php
index 5b50e488..325716ef 100644
--- a/exercises/practice/scrabble-score/ScrabbleScore.php
+++ b/exercises/practice/scrabble-score/ScrabbleScore.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function score(string $word): int
 {
     throw new \BadFunctionCallException("Implement the score function");
diff --git a/exercises/practice/scrabble-score/ScrabbleScoreTest.php b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
index 6993675f..a51a0234 100644
--- a/exercises/practice/scrabble-score/ScrabbleScoreTest.php
+++ b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Calculate the value of scrabble score for a given word.
  */
diff --git a/exercises/practice/series/.meta/example.php b/exercises/practice/series/.meta/example.php
index 6ca364d3..096d7685 100644
--- a/exercises/practice/series/.meta/example.php
+++ b/exercises/practice/series/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function slices($series, $size)
 {
     if ($size > strlen($series) || $size < 1) {
diff --git a/exercises/practice/series/Series.php b/exercises/practice/series/Series.php
index 5e027b11..78d61def 100644
--- a/exercises/practice/series/Series.php
+++ b/exercises/practice/series/Series.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function slices(string $digits, int $series): array
 {
     throw new \BadFunctionCallException("Implement the slices function");
diff --git a/exercises/practice/series/SeriesTest.php b/exercises/practice/series/SeriesTest.php
index 9081c37c..d3b21e6c 100644
--- a/exercises/practice/series/SeriesTest.php
+++ b/exercises/practice/series/SeriesTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SeriesTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/sieve/.meta/example.php b/exercises/practice/sieve/.meta/example.php
index f10536b9..f894eaa7 100644
--- a/exercises/practice/sieve/.meta/example.php
+++ b/exercises/practice/sieve/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function sieve($number)
 {
     if ($number == 1) {
diff --git a/exercises/practice/sieve/Sieve.php b/exercises/practice/sieve/Sieve.php
index e55afb8e..9e85a302 100644
--- a/exercises/practice/sieve/Sieve.php
+++ b/exercises/practice/sieve/Sieve.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function sieve(int $number): array
 {
     throw new \BadFunctionCallException("Implement the sieve function");
diff --git a/exercises/practice/sieve/SieveTest.php b/exercises/practice/sieve/SieveTest.php
index 944ce5b6..ba58f409 100644
--- a/exercises/practice/sieve/SieveTest.php
+++ b/exercises/practice/sieve/SieveTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SieveTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/space-age/.meta/example.php b/exercises/practice/space-age/.meta/example.php
index 3a374e74..0f47f72a 100644
--- a/exercises/practice/space-age/.meta/example.php
+++ b/exercises/practice/space-age/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SpaceAge
 {
     public $seconds;
diff --git a/exercises/practice/space-age/SpaceAge.php b/exercises/practice/space-age/SpaceAge.php
index 3249fdf1..754f7582 100644
--- a/exercises/practice/space-age/SpaceAge.php
+++ b/exercises/practice/space-age/SpaceAge.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SpaceAge
 {
     public function __construct(int $seconds)
diff --git a/exercises/practice/space-age/SpaceAgeTest.php b/exercises/practice/space-age/SpaceAgeTest.php
index d051b542..67674917 100644
--- a/exercises/practice/space-age/SpaceAgeTest.php
+++ b/exercises/practice/space-age/SpaceAgeTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SpaceAgeTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/sum-of-multiples/.meta/example.php b/exercises/practice/sum-of-multiples/.meta/example.php
index 51a26926..c796d15b 100644
--- a/exercises/practice/sum-of-multiples/.meta/example.php
+++ b/exercises/practice/sum-of-multiples/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function sumOfMultiples($number, $multiples)
 {
     $numbers = [];
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiples.php b/exercises/practice/sum-of-multiples/SumOfMultiples.php
index 2e77bea5..96ec9a25 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiples.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiples.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function sumOfMultiples(int $number, array $multiples): int
 {
     throw new \BadFunctionCallException("Implement the sumOfMultiples function");
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
index 8dbc149e..a35e623c 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class SumOfMultiplesTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/transpose/.meta/example.php b/exercises/practice/transpose/.meta/example.php
index ed3a7968..6a133bca 100644
--- a/exercises/practice/transpose/.meta/example.php
+++ b/exercises/practice/transpose/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * Transpose multi line text into Rows become columns and columns become rows.
  * Eg: http://en.wikipedia.org/wiki/Transpose
diff --git a/exercises/practice/transpose/Transpose.php b/exercises/practice/transpose/Transpose.php
index 5a54db91..f1839f39 100644
--- a/exercises/practice/transpose/Transpose.php
+++ b/exercises/practice/transpose/Transpose.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function transpose(array $input): array
 {
     throw new \BadFunctionCallException("Implement the transpose function");
diff --git a/exercises/practice/transpose/TransposeTest.php b/exercises/practice/transpose/TransposeTest.php
index db9eeeda..99daff71 100644
--- a/exercises/practice/transpose/TransposeTest.php
+++ b/exercises/practice/transpose/TransposeTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class TransposeTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/triangle/.meta/example.php b/exercises/practice/triangle/.meta/example.php
index 477fd9c2..fdf59a5a 100644
--- a/exercises/practice/triangle/.meta/example.php
+++ b/exercises/practice/triangle/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Triangle
 {
     protected $sideA;
diff --git a/exercises/practice/triangle/Triangle.php b/exercises/practice/triangle/Triangle.php
index 446194a0..6efe3b5b 100644
--- a/exercises/practice/triangle/Triangle.php
+++ b/exercises/practice/triangle/Triangle.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class Triangle
 {
     public function __construct(int $a, int $b, int $c)
diff --git a/exercises/practice/triangle/TriangleTest.php b/exercises/practice/triangle/TriangleTest.php
index 9b8d2922..ec9127c0 100644
--- a/exercises/practice/triangle/TriangleTest.php
+++ b/exercises/practice/triangle/TriangleTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class TriangleTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/trinary/.meta/example.php b/exercises/practice/trinary/.meta/example.php
index 5c0022d9..6a4b6745 100644
--- a/exercises/practice/trinary/.meta/example.php
+++ b/exercises/practice/trinary/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toDecimal($ternaryString, $base = 3)
 {
     if (!preg_match('/^[0-2]+$/', $ternaryString)) {
diff --git a/exercises/practice/trinary/Trinary.php b/exercises/practice/trinary/Trinary.php
index c75f7156..e34acf50 100644
--- a/exercises/practice/trinary/Trinary.php
+++ b/exercises/practice/trinary/Trinary.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function toDecimal(string $number): int
 {
     throw new \BadFunctionCallException("Implement the toDecimal function");
diff --git a/exercises/practice/trinary/TrinaryTest.php b/exercises/practice/trinary/TrinaryTest.php
index 20966e3a..fa328d42 100644
--- a/exercises/practice/trinary/TrinaryTest.php
+++ b/exercises/practice/trinary/TrinaryTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class TrinaryTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/two-fer/.meta/example.php b/exercises/practice/two-fer/.meta/example.php
index 2e24a1f7..6a72f9c6 100644
--- a/exercises/practice/two-fer/.meta/example.php
+++ b/exercises/practice/two-fer/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function twoFer(string $name = 'you'): string
 {
     return "One for $name, one for me.";
diff --git a/exercises/practice/two-fer/TwoFer.php b/exercises/practice/two-fer/TwoFer.php
index 0604d2d7..edd032fc 100644
--- a/exercises/practice/two-fer/TwoFer.php
+++ b/exercises/practice/two-fer/TwoFer.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function twoFer(string $name): string
 {
     throw new \BadFunctionCallException("Implement the twoFer function");
diff --git a/exercises/practice/two-fer/TwoFerTest.php b/exercises/practice/two-fer/TwoFerTest.php
index e25c538c..7ed0c297 100644
--- a/exercises/practice/two-fer/TwoFerTest.php
+++ b/exercises/practice/two-fer/TwoFerTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class TwoFerTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/variable-length-quantity/.meta/example.php b/exercises/practice/variable-length-quantity/.meta/example.php
index db6e6e91..9dbfe63f 100644
--- a/exercises/practice/variable-length-quantity/.meta/example.php
+++ b/exercises/practice/variable-length-quantity/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 /**
  * @param array $integers
  * @return array
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
index 14740e94..188592cf 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function vlq_encode(array $input): array
 {
     throw new \BadFunctionCallException("Implement the vlq_encode function");
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
index 608e0c34..bc8d0f7f 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class VariableLengthQuantityTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/word-count/.meta/example.php b/exercises/practice/word-count/.meta/example.php
index 0197a591..ef4133bd 100644
--- a/exercises/practice/word-count/.meta/example.php
+++ b/exercises/practice/word-count/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function wordCount($phrase)
 {
     $count = [];
diff --git a/exercises/practice/word-count/WordCount.php b/exercises/practice/word-count/WordCount.php
index f84c42fd..9e2e9f74 100644
--- a/exercises/practice/word-count/WordCount.php
+++ b/exercises/practice/word-count/WordCount.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function wordCount(string $words): array
 {
     throw new \BadFunctionCallException("Implement the wordCount function");
diff --git a/exercises/practice/word-count/WordCountTest.php b/exercises/practice/word-count/WordCountTest.php
index 6bc0b40f..6960f330 100644
--- a/exercises/practice/word-count/WordCountTest.php
+++ b/exercises/practice/word-count/WordCountTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class WordCountTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/wordy/.meta/example.php b/exercises/practice/wordy/.meta/example.php
index 0e2c8493..d5dc9e34 100644
--- a/exercises/practice/wordy/.meta/example.php
+++ b/exercises/practice/wordy/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function calculate($question = "")
 {
     preg_match(
diff --git a/exercises/practice/wordy/Wordy.php b/exercises/practice/wordy/Wordy.php
index f523eb5e..77729e5a 100644
--- a/exercises/practice/wordy/Wordy.php
+++ b/exercises/practice/wordy/Wordy.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function calculate(string $input): int
 {
     throw new \BadFunctionCallException("Implement the calculate function");
diff --git a/exercises/practice/wordy/WordyTest.php b/exercises/practice/wordy/WordyTest.php
index 77722fa2..77e49563 100644
--- a/exercises/practice/wordy/WordyTest.php
+++ b/exercises/practice/wordy/WordyTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class WordyTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void

From d31570fea347dedad43b424bdc1ec5c5b64a2608 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 16:50:00 +0200
Subject: [PATCH 2/8] Fix failing tests

---
 exercises/practice/meetup/MeetupTest.php | 190 +++++++++++------------
 1 file changed, 95 insertions(+), 95 deletions(-)

diff --git a/exercises/practice/meetup/MeetupTest.php b/exercises/practice/meetup/MeetupTest.php
index b885f2e8..bef7fbfe 100644
--- a/exercises/practice/meetup/MeetupTest.php
+++ b/exercises/practice/meetup/MeetupTest.php
@@ -9,476 +9,476 @@ public static function setUpBeforeClass(): void
 
     public function testMonteenthOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/13"), meetup_day(2013, 5, "teenth", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/13"), meetup_day(2013, "5", "teenth", "Monday"));
     }
 
     public function testMonteenthOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/19"), meetup_day(2013, 8, "teenth", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/19"), meetup_day(2013, "8", "teenth", "Monday"));
     }
 
     public function testMonteenthOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/16"), meetup_day(2013, 9, "teenth", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/16"), meetup_day(2013, "9", "teenth", "Monday"));
     }
 
     public function testTuesteenthOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/19"), meetup_day(2013, 3, "teenth", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/19"), meetup_day(2013, "3", "teenth", "Tuesday"));
     }
 
     public function testTuesteenthOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/16"), meetup_day(2013, 4, "teenth", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/16"), meetup_day(2013, "4", "teenth", "Tuesday"));
     }
 
     public function testTuesteenthOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/13"), meetup_day(2013, 8, "teenth", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/13"), meetup_day(2013, "8", "teenth", "Tuesday"));
     }
 
     public function testWednesteenthOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/16"), meetup_day(2013, 1, "teenth", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/16"), meetup_day(2013, "1", "teenth", "Wednesday"));
     }
 
     public function testWednesteenthOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/13"), meetup_day(2013, 2, "teenth", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/13"), meetup_day(2013, "2", "teenth", "Wednesday"));
     }
 
     public function testWednesteenthOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/19"), meetup_day(2013, 6, "teenth", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/19"), meetup_day(2013, "6", "teenth", "Wednesday"));
     }
 
     public function testThursteenthOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/16"), meetup_day(2013, 5, "teenth", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/16"), meetup_day(2013, "5", "teenth", "Thursday"));
     }
 
     public function testThursteenthOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/13"), meetup_day(2013, 6, "teenth", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/13"), meetup_day(2013, "6", "teenth", "Thursday"));
     }
 
     public function testThursteenthOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/19"), meetup_day(2013, 9, "teenth", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/19"), meetup_day(2013, "9", "teenth", "Thursday"));
     }
 
     public function testFriteenthOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/19"), meetup_day(2013, 4, "teenth", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/19"), meetup_day(2013, "4", "teenth", "Friday"));
     }
 
     public function testFriteenthOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/16"), meetup_day(2013, 8, "teenth", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/16"), meetup_day(2013, "8", "teenth", "Friday"));
     }
 
     public function testFriteenthOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/13"), meetup_day(2013, 9, "teenth", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/13"), meetup_day(2013, "9", "teenth", "Friday"));
     }
 
     public function testSaturteenthOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/16"), meetup_day(2013, 2, "teenth", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/16"), meetup_day(2013, "2", "teenth", "Saturday"));
     }
 
     public function testSaturteenthOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/13"), meetup_day(2013, 4, "teenth", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/13"), meetup_day(2013, "4", "teenth", "Saturday"));
     }
 
     public function testSaturteenthOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/19"), meetup_day(2013, 10, "teenth", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/19"), meetup_day(2013, "10", "teenth", "Saturday"));
     }
 
     public function testSunteenthOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/19"), meetup_day(2013, 5, "teenth", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/19"), meetup_day(2013, "5", "teenth", "Sunday"));
     }
 
     public function testSunteenthOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/16"), meetup_day(2013, 6, "teenth", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/16"), meetup_day(2013, "6", "teenth", "Sunday"));
     }
 
     public function testSunteenthOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/13"), meetup_day(2013, 10, "teenth", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/13"), meetup_day(2013, "10", "teenth", "Sunday"));
     }
 
     public function testFirstMondayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/4"), meetup_day(2013, 3, "first", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/4"), meetup_day(2013, "3", "first", "Monday"));
     }
 
     public function testFirstMondayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/1"), meetup_day(2013, 4, "first", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/1"), meetup_day(2013, "4", "first", "Monday"));
     }
 
     public function testFirstTuesdayOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/7"), meetup_day(2013, 5, "first", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/7"), meetup_day(2013, "5", "first", "Tuesday"));
     }
 
     public function testFirstTuesdayOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/4"), meetup_day(2013, 6, "first", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/4"), meetup_day(2013, "6", "first", "Tuesday"));
     }
 
     public function testFirstWednesdayOfJuly2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/7/3"), meetup_day(2013, 7, "first", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/7/3"), meetup_day(2013, "7", "first", "Wednesday"));
     }
 
     public function testFirstWednesdayOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/7"), meetup_day(2013, 8, "first", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/7"), meetup_day(2013, "8", "first", "Wednesday"));
     }
 
     public function testFirstThursdayOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/5"), meetup_day(2013, 9, "first", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/5"), meetup_day(2013, "9", "first", "Thursday"));
     }
 
     public function testFirstThursdayOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/3"), meetup_day(2013, 10, "first", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/3"), meetup_day(2013, "10", "first", "Thursday"));
     }
 
     public function testFirstFridayOfNovember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/11/1"), meetup_day(2013, 11, "first", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/11/1"), meetup_day(2013, "11", "first", "Friday"));
     }
 
     public function testFirstFridayOfDecember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/12/6"), meetup_day(2013, 12, "first", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/12/6"), meetup_day(2013, "12", "first", "Friday"));
     }
 
     public function testFirstSaturdayOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/5"), meetup_day(2013, 1, "first", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/5"), meetup_day(2013, "1", "first", "Saturday"));
     }
 
     public function testFirstSaturdayOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/2"), meetup_day(2013, 2, "first", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/2"), meetup_day(2013, "2", "first", "Saturday"));
     }
 
     public function testFirstSundayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/3"), meetup_day(2013, 3, "first", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/3"), meetup_day(2013, "3", "first", "Sunday"));
     }
 
     public function testFirstSundayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/7"), meetup_day(2013, 4, "first", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/7"), meetup_day(2013, "4", "first", "Sunday"));
     }
 
     public function testSecondMondayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/11"), meetup_day(2013, 3, "second", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/11"), meetup_day(2013, "3", "second", "Monday"));
     }
 
     public function testSecondMondayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/8"), meetup_day(2013, 4, "second", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/8"), meetup_day(2013, "4", "second", "Monday"));
     }
 
     public function testSecondTuesdayOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/14"), meetup_day(2013, 5, "second", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/14"), meetup_day(2013, "5", "second", "Tuesday"));
     }
 
     public function testSecondTuesdayOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/11"), meetup_day(2013, 6, "second", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/11"), meetup_day(2013, "6", "second", "Tuesday"));
     }
 
     public function testSecondWednesdayOfJuly2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/7/10"), meetup_day(2013, 7, "second", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/7/10"), meetup_day(2013, "7", "second", "Wednesday"));
     }
 
     public function testSecondWednesdayOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/14"), meetup_day(2013, 8, "second", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/14"), meetup_day(2013, "8", "second", "Wednesday"));
     }
 
     public function testSecondThursdayOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/12"), meetup_day(2013, 9, "second", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/12"), meetup_day(2013, "9", "second", "Thursday"));
     }
 
     public function testSecondThursdayOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/10"), meetup_day(2013, 10, "second", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/10"), meetup_day(2013, "10", "second", "Thursday"));
     }
 
     public function testSecondFridayOfNovember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/11/8"), meetup_day(2013, 11, "second", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/11/8"), meetup_day(2013, "11", "second", "Friday"));
     }
 
     public function testSecondFridayOfDecember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/12/13"), meetup_day(2013, 12, "second", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/12/13"), meetup_day(2013, "12", "second", "Friday"));
     }
 
     public function testSecondSaturdayOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/12"), meetup_day(2013, 1, "second", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/12"), meetup_day(2013, "1", "second", "Saturday"));
     }
 
     public function testSecondSaturdayOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/9"), meetup_day(2013, 2, "second", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/9"), meetup_day(2013, "2", "second", "Saturday"));
     }
 
     public function testSecondSundayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/10"), meetup_day(2013, 3, "second", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/10"), meetup_day(2013, "3", "second", "Sunday"));
     }
 
     public function testSecondSundayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/14"), meetup_day(2013, 4, "second", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/14"), meetup_day(2013, "4", "second", "Sunday"));
     }
 
     public function testThirdMondayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/18"), meetup_day(2013, 3, "third", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/18"), meetup_day(2013, "3", "third", "Monday"));
     }
 
     public function testThirdMondayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/15"), meetup_day(2013, 4, "third", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/15"), meetup_day(2013, "4", "third", "Monday"));
     }
 
     public function testThirdTuesdayOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/21"), meetup_day(2013, 5, "third", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/21"), meetup_day(2013, "5", "third", "Tuesday"));
     }
 
     public function testThirdTuesdayOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/18"), meetup_day(2013, 6, "third", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/18"), meetup_day(2013, "6", "third", "Tuesday"));
     }
 
     public function testThirdWednesdayOfJuly2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/7/17"), meetup_day(2013, 7, "third", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/7/17"), meetup_day(2013, "7", "third", "Wednesday"));
     }
 
     public function testThirdWednesdayOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/21"), meetup_day(2013, 8, "third", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/21"), meetup_day(2013, "8", "third", "Wednesday"));
     }
 
     public function testThirdThursdayOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/19"), meetup_day(2013, 9, "third", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/19"), meetup_day(2013, "9", "third", "Thursday"));
     }
 
     public function testThirdThursdayOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/17"), meetup_day(2013, 10, "third", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/17"), meetup_day(2013, "10", "third", "Thursday"));
     }
 
     public function testThirdFridayOfNovember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/11/15"), meetup_day(2013, 11, "third", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/11/15"), meetup_day(2013, "11", "third", "Friday"));
     }
 
     public function testThirdFridayOfDecember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/12/20"), meetup_day(2013, 12, "third", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/12/20"), meetup_day(2013, "12", "third", "Friday"));
     }
 
     public function testThirdSaturdayOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/19"), meetup_day(2013, 1, "third", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/19"), meetup_day(2013, "1", "third", "Saturday"));
     }
 
     public function testThirdSaturdayOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/16"), meetup_day(2013, 2, "third", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/16"), meetup_day(2013, "2", "third", "Saturday"));
     }
 
     public function testThirdSundayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/17"), meetup_day(2013, 3, "third", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/17"), meetup_day(2013, "3", "third", "Sunday"));
     }
 
     public function testThirdSundayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/21"), meetup_day(2013, 4, "third", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/21"), meetup_day(2013, "4", "third", "Sunday"));
     }
 
     public function testFourthMondayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/25"), meetup_day(2013, 3, "fourth", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/25"), meetup_day(2013, "3", "fourth", "Monday"));
     }
 
     public function testFourthMondayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/22"), meetup_day(2013, 4, "fourth", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/22"), meetup_day(2013, "4", "fourth", "Monday"));
     }
 
     public function testFourthTuesdayOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/28"), meetup_day(2013, 5, "fourth", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/28"), meetup_day(2013, "5", "fourth", "Tuesday"));
     }
 
     public function testFourthTuesdayOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/25"), meetup_day(2013, 6, "fourth", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/25"), meetup_day(2013, "6", "fourth", "Tuesday"));
     }
 
     public function testFourthWednesdayOfJuly2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/7/24"), meetup_day(2013, 7, "fourth", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/7/24"), meetup_day(2013, "7", "fourth", "Wednesday"));
     }
 
     public function testFourthWednesdayOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/28"), meetup_day(2013, 8, "fourth", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/28"), meetup_day(2013, "8", "fourth", "Wednesday"));
     }
 
     public function testFourthThursdayOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/26"), meetup_day(2013, 9, "fourth", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/26"), meetup_day(2013, "9", "fourth", "Thursday"));
     }
 
     public function testFourthThursdayOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/24"), meetup_day(2013, 10, "fourth", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/24"), meetup_day(2013, "10", "fourth", "Thursday"));
     }
 
     public function testFourthFridayOfNovember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/11/22"), meetup_day(2013, 11, "fourth", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/11/22"), meetup_day(2013, "11", "fourth", "Friday"));
     }
 
     public function testFourthFridayOfDecember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/12/27"), meetup_day(2013, 12, "fourth", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/12/27"), meetup_day(2013, "12", "fourth", "Friday"));
     }
 
     public function testFourthSaturdayOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/26"), meetup_day(2013, 1, "fourth", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/26"), meetup_day(2013, "1", "fourth", "Saturday"));
     }
 
     public function testFourthSaturdayOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/23"), meetup_day(2013, 2, "fourth", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/23"), meetup_day(2013, "2", "fourth", "Saturday"));
     }
 
     public function testFourthSundayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/24"), meetup_day(2013, 3, "fourth", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/24"), meetup_day(2013, "3", "fourth", "Sunday"));
     }
 
     public function testFourthSundayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/28"), meetup_day(2013, 4, "fourth", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/28"), meetup_day(2013, "4", "fourth", "Sunday"));
     }
 
     public function testLastMondayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/25"), meetup_day(2013, 3, "last", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/25"), meetup_day(2013, "3", "last", "Monday"));
     }
 
     public function testLastMondayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/29"), meetup_day(2013, 4, "last", "Monday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/29"), meetup_day(2013, "4", "last", "Monday"));
     }
 
     public function testLastTuesdayOfMay2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/5/28"), meetup_day(2013, 5, "last", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/5/28"), meetup_day(2013, "5", "last", "Tuesday"));
     }
 
     public function testLastTuesdayOfJune2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/6/25"), meetup_day(2013, 6, "last", "Tuesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/6/25"), meetup_day(2013, "6", "last", "Tuesday"));
     }
 
     public function testLastWednesdayOfJuly2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/7/31"), meetup_day(2013, 7, "last", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/7/31"), meetup_day(2013, "7", "last", "Wednesday"));
     }
 
     public function testLastWednesdayOfAugust2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/8/28"), meetup_day(2013, 8, "last", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2013/8/28"), meetup_day(2013, "8", "last", "Wednesday"));
     }
 
     public function testLastThursdayOfSeptember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/9/26"), meetup_day(2013, 9, "last", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/9/26"), meetup_day(2013, "9", "last", "Thursday"));
     }
 
     public function testLastThursdayOfOctober2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/10/31"), meetup_day(2013, 10, "last", "Thursday"));
+        $this->assertEquals(new DateTimeImmutable("2013/10/31"), meetup_day(2013, "10", "last", "Thursday"));
     }
 
     public function testLastFridayOfNovember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/11/29"), meetup_day(2013, 11, "last", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/11/29"), meetup_day(2013, "11", "last", "Friday"));
     }
 
     public function testLastFridayOfDecember2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/12/27"), meetup_day(2013, 12, "last", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2013/12/27"), meetup_day(2013, "12", "last", "Friday"));
     }
 
     public function testLastSaturdayOfJanuary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/1/26"), meetup_day(2013, 1, "last", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/1/26"), meetup_day(2013, "1", "last", "Saturday"));
     }
 
     public function testLastSaturdayOfFebruary2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/2/23"), meetup_day(2013, 2, "last", "Saturday"));
+        $this->assertEquals(new DateTimeImmutable("2013/2/23"), meetup_day(2013, "2", "last", "Saturday"));
     }
 
     public function testLastSundayOfMarch2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/3/31"), meetup_day(2013, 3, "last", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/3/31"), meetup_day(2013, "3", "last", "Sunday"));
     }
 
     public function testLastSundayOfApril2013(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2013/4/28"), meetup_day(2013, 4, "last", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2013/4/28"), meetup_day(2013, "4", "last", "Sunday"));
     }
 
     public function testLastWednesdayOfFebruary2012(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2012/2/29"), meetup_day(2012, 2, "last", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2012/2/29"), meetup_day(2012, "2", "last", "Wednesday"));
     }
 
     public function testLastWednesdayOfDecember2014(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2014/12/31"), meetup_day(2014, 12, "last", "Wednesday"));
+        $this->assertEquals(new DateTimeImmutable("2014/12/31"), meetup_day(2014, "12", "last", "Wednesday"));
     }
 
     public function testLastSundayOfFebruary2015(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2015/2/22"), meetup_day(2015, 2, "last", "Sunday"));
+        $this->assertEquals(new DateTimeImmutable("2015/2/22"), meetup_day(2015, "2", "last", "Sunday"));
     }
 
     public function testFirstFridayOfDecember2012(): void
     {
-        $this->assertEquals(new DateTimeImmutable("2012/12/7"), meetup_day(2012, 12, "first", "Friday"));
+        $this->assertEquals(new DateTimeImmutable("2012/12/7"), meetup_day(2012, "12", "first", "Friday"));
     }
 }

From 32f44670d8fb66022f9da06dcf575a490a752507 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 16:55:29 +0200
Subject: [PATCH 3/8] Add phpcs strict type rule

---
 .github/workflows/exercise-lint-phpcs-psr-12.yml | 4 ++++
 .gitignore                                       | 3 +++
 composer.json                                    | 6 ++++++
 phpcs-php.xml                                    | 1 +
 4 files changed, 14 insertions(+)
 create mode 100644 composer.json

diff --git a/.github/workflows/exercise-lint-phpcs-psr-12.yml b/.github/workflows/exercise-lint-phpcs-psr-12.yml
index df4885d0..712035b5 100644
--- a/.github/workflows/exercise-lint-phpcs-psr-12.yml
+++ b/.github/workflows/exercise-lint-phpcs-psr-12.yml
@@ -31,6 +31,7 @@ jobs:
         with:
           version: ${{ matrix.php-version }}
           extensions: gmp
+          tools: composer
 
       - name: Install dependencies
         shell: bash
@@ -38,6 +39,9 @@ jobs:
           curl -Lo bin/phpcs.phar https://squizlabs.github.io/PHP_CodeSniffer/phpcs.phar
           chmod +x bin/phpcs.phar
 
+      - name: Install composer packages
+        run: composer install
+
       - name: Lint exercises
         shell: bash
         env:
diff --git a/.gitignore b/.gitignore
index 72aa4a12..378b241b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,6 @@ tmp
 .phpunit.result.cache
 bin/configlet
 bin/configlet.exe
+
+/vendor/
+composer.lock
diff --git a/composer.json b/composer.json
new file mode 100644
index 00000000..8802a1dd
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,6 @@
+{
+    "name": "exercism/php",
+    "require-dev": {
+        "slevomat/coding-standard": "^7.0"
+    }
+}
diff --git a/phpcs-php.xml b/phpcs-php.xml
index 9585f413..c06bf867 100644
--- a/phpcs-php.xml
+++ b/phpcs-php.xml
@@ -8,4 +8,5 @@
     <exclude name="PSR1.Classes.ClassDeclaration.MultipleClasses" />
     <exclude name="PSR1.Files.SideEffects.FoundWithSymbols" />
   </rule>
+  <rule ref="vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/TypeHints/DeclareStrictTypesSniff.php" />
 </ruleset>

From 168eee72ab1717a7df3d3b5e267aa42b97dec7d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 17:23:31 +0200
Subject: [PATCH 4/8] Add rule to ensure strict types

---
 .../workflows/exercise-lint-phpcs-psr-12.yml    |  7 ++-----
 composer.json                                   | 17 +++++++++++++----
 .../practice/mask-credit-card/.meta/example.php |  2 ++
 .../mask-credit-card/MaskCreditCard.php         |  2 ++
 .../mask-credit-card/MaskCreditCardTest.php     |  2 ++
 exercises/practice/meetup/MeetupTest.php        |  2 ++
 .../practice/ocr-numbers/OcrNumbersTest.php     |  2 ++
 .../palindrome-products/.meta/example.php       |  2 ++
 .../rna-transcription/RnaTranscriptionTest.php  |  2 ++
 phpcs-php.xml                                   |  7 ++++++-
 10 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/exercise-lint-phpcs-psr-12.yml b/.github/workflows/exercise-lint-phpcs-psr-12.yml
index 712035b5..6139e55a 100644
--- a/.github/workflows/exercise-lint-phpcs-psr-12.yml
+++ b/.github/workflows/exercise-lint-phpcs-psr-12.yml
@@ -29,7 +29,7 @@ jobs:
 
       - uses: shivammathur/setup-php@46fc8a2fd7cba50512858026dc8f0947c8a7a0e8
         with:
-          version: ${{ matrix.php-version }}
+          php-version: ${{ matrix.php-version }}
           extensions: gmp
           tools: composer
 
@@ -44,7 +44,4 @@ jobs:
 
       - name: Lint exercises
         shell: bash
-        env:
-          PHPCS_BIN: 'bin/phpcs.phar'
-          PHPCS_RULES: 'phpcs-php.xml'
-        run: bin/lint.sh
+        run: composer lint:check
diff --git a/composer.json b/composer.json
index 8802a1dd..e7f24976 100644
--- a/composer.json
+++ b/composer.json
@@ -1,6 +1,15 @@
 {
-    "name": "exercism/php",
-    "require-dev": {
-        "slevomat/coding-standard": "^7.0"
-    }
+  "name": "exercism/php",
+  "autoload": {
+    "Exercism\\": "src",
+    "Exercism\\Exercises\\": "exercises"
+  },
+  "require-dev": {
+    "slevomat/coding-standard": "^7.0",
+    "squizlabs/php_codesniffer": "^3.6"
+  },
+  "scripts": {
+    "lint:check": "./vendor/bin/phpcs --standard=phpcs-php.xml ./exercises",
+    "lint:fix": "./vendor/bin/phpcbf --standard=phpcs-php.xml ./exercises"
+  }
 }
diff --git a/exercises/practice/mask-credit-card/.meta/example.php b/exercises/practice/mask-credit-card/.meta/example.php
index ce0bd415..75ce376b 100644
--- a/exercises/practice/mask-credit-card/.meta/example.php
+++ b/exercises/practice/mask-credit-card/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function maskify(string $cc): string
 {
     // Do no mask if cc less than 6 or empty string
diff --git a/exercises/practice/mask-credit-card/MaskCreditCard.php b/exercises/practice/mask-credit-card/MaskCreditCard.php
index 23a90763..e00446b8 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCard.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCard.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function maskify(string $cc): string
 {
     throw new \BadFunctionCallException("Implement the maskify function");
diff --git a/exercises/practice/mask-credit-card/MaskCreditCardTest.php b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
index 93266646..44b1af93 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCardTest.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class MaskCreditCardTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/meetup/MeetupTest.php b/exercises/practice/meetup/MeetupTest.php
index bef7fbfe..63bf00ab 100644
--- a/exercises/practice/meetup/MeetupTest.php
+++ b/exercises/practice/meetup/MeetupTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class MeetupTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/ocr-numbers/OcrNumbersTest.php b/exercises/practice/ocr-numbers/OcrNumbersTest.php
index ae0918ae..65551f05 100644
--- a/exercises/practice/ocr-numbers/OcrNumbersTest.php
+++ b/exercises/practice/ocr-numbers/OcrNumbersTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class OcrNumbersTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/exercises/practice/palindrome-products/.meta/example.php b/exercises/practice/palindrome-products/.meta/example.php
index 9a29f8d4..c036c83c 100644
--- a/exercises/practice/palindrome-products/.meta/example.php
+++ b/exercises/practice/palindrome-products/.meta/example.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 function generatePalindromeProduct(array $range): ?int
 {
     $palindromes = [];
diff --git a/exercises/practice/rna-transcription/RnaTranscriptionTest.php b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
index c4169807..fb5b15b8 100644
--- a/exercises/practice/rna-transcription/RnaTranscriptionTest.php
+++ b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 class RnaTranscriptionTest extends PHPUnit\Framework\TestCase
 {
     public static function setUpBeforeClass(): void
diff --git a/phpcs-php.xml b/phpcs-php.xml
index c06bf867..3849bec7 100644
--- a/phpcs-php.xml
+++ b/phpcs-php.xml
@@ -8,5 +8,10 @@
     <exclude name="PSR1.Classes.ClassDeclaration.MultipleClasses" />
     <exclude name="PSR1.Files.SideEffects.FoundWithSymbols" />
   </rule>
-  <rule ref="vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/TypeHints/DeclareStrictTypesSniff.php" />
+  <rule ref="vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/TypeHints/DeclareStrictTypesSniff.php">
+    <properties>
+      <property name="newlinesCountBetweenOpenTagAndDeclare" type="int" value="2" />
+      <property name="spacesCountAroundEqualsSign" type="int" value="0" />
+    </properties>
+  </rule>
 </ruleset>

From 4b511e5972841694e15b4e0c8650c83f2d4080b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 18:10:21 +0200
Subject: [PATCH 5/8] Add explanation

---
 .../practice/accumulate/.meta/example.php     | 15 +++++
 exercises/practice/accumulate/Accumulate.php  | 15 +++++
 .../practice/accumulate/AccumulateTest.php    | 15 +++++
 exercises/practice/acronym/.meta/example.php  | 15 +++++
 exercises/practice/acronym/Acronym.php        | 15 +++++
 exercises/practice/acronym/AcronymTest.php    | 15 +++++
 .../practice/affine-cipher/.meta/example.php  | 15 +++++
 .../practice/affine-cipher/AffineCipher.php   | 15 +++++
 .../affine-cipher/AffineCipherTest.php        | 15 +++++
 .../practice/all-your-base/.meta/example.php  | 15 +++++
 .../practice/all-your-base/AllYourBase.php    | 15 +++++
 .../all-your-base/AllYourBaseTest.php         | 15 +++++
 .../practice/allergies/.meta/example.php      | 15 +++++
 exercises/practice/allergies/Allergies.php    | 15 +++++
 .../practice/allergies/AllergiesTest.php      | 15 +++++
 exercises/practice/anagram/.meta/example.php  | 15 +++++
 exercises/practice/anagram/Anagram.php        | 15 +++++
 exercises/practice/anagram/AnagramTest.php    | 15 +++++
 .../armstrong-numbers/.meta/example.php       | 15 +++++
 .../armstrong-numbers/ArmstrongNumbers.php    | 15 +++++
 .../ArmstrongNumbersTest.php                  | 15 +++++
 .../practice/atbash-cipher/.meta/example.php  | 15 +++++
 .../practice/atbash-cipher/AtbashCipher.php   | 15 +++++
 .../atbash-cipher/AtbashCipherTest.php        | 15 +++++
 .../practice/beer-song/.meta/example.php      | 15 +++++
 exercises/practice/beer-song/BeerSong.php     | 15 +++++
 exercises/practice/beer-song/BeerSongTest.php | 15 +++++
 .../practice/binary-search/.meta/example.php  | 15 +++++
 .../practice/binary-search/BinarySearch.php   | 15 +++++
 .../binary-search/BinarySearchTest.php        | 15 +++++
 exercises/practice/binary/.meta/example.php   | 15 +++++
 exercises/practice/binary/Binary.php          | 15 +++++
 exercises/practice/binary/BinaryTest.php      | 15 +++++
 exercises/practice/bob/.meta/example.php      | 15 +++++
 exercises/practice/bob/Bob.php                | 15 +++++
 exercises/practice/bob/BobTest.php            | 15 +++++
 .../practice/book-store/.meta/example.php     | 15 +++++
 exercises/practice/book-store/BookStore.php   | 15 +++++
 .../practice/book-store/BookStoreTest.php     | 15 +++++
 exercises/practice/bowling/.meta/example.php  | 15 +++++
 exercises/practice/bowling/Bowling.php        | 15 +++++
 exercises/practice/bowling/BowlingTest.php    | 15 +++++
 exercises/practice/change/.meta/example.php   | 15 +++++
 exercises/practice/change/Change.php          | 15 +++++
 exercises/practice/change/ChangeTest.php      | 15 +++++
 exercises/practice/clock/.meta/example.php    | 15 +++++
 exercises/practice/clock/Clock.php            | 15 +++++
 exercises/practice/clock/ClockTest.php        | 15 +++++
 .../collatz-conjecture/.meta/example.php      | 15 +++++
 .../collatz-conjecture/CollatzConjecture.php  | 15 +++++
 .../CollatzConjectureTest.php                 | 15 +++++
 exercises/practice/connect/.meta/example.php  | 15 +++++
 exercises/practice/connect/Connect.php        | 15 +++++
 exercises/practice/connect/ConnectTest.php    | 15 +++++
 .../practice/crypto-square/.meta/example.php  | 15 +++++
 .../practice/crypto-square/CryptoSquare.php   | 15 +++++
 .../crypto-square/CryptoSquareTest.php        | 15 +++++
 exercises/practice/diamond/.meta/example.php  | 15 +++++
 exercises/practice/diamond/Diamond.php        | 15 +++++
 exercises/practice/diamond/DiamondTest.php    | 15 +++++
 .../difference-of-squares/.meta/example.php   | 15 +++++
 .../DifferenceOfSquares.php                   | 15 +++++
 .../DifferenceOfSquaresTest.php               | 15 +++++
 exercises/practice/etl/.meta/example.php      | 15 +++++
 exercises/practice/etl/Etl.php                | 15 +++++
 exercises/practice/etl/EtlTest.php            | 15 +++++
 .../practice/flatten-array/.meta/example.php  | 15 +++++
 .../practice/flatten-array/FlattenArray.php   | 15 +++++
 .../flatten-array/FlattenArrayTest.php        | 15 +++++
 .../practice/gigasecond/.meta/example.php     | 15 +++++
 exercises/practice/gigasecond/Gigasecond.php  | 15 +++++
 .../practice/gigasecond/GigasecondTest.php    | 15 +++++
 .../practice/grade-school/.meta/example.php   | 15 +++++
 .../practice/grade-school/GradeSchool.php     | 15 +++++
 .../practice/grade-school/GradeSchoolTest.php | 15 +++++
 exercises/practice/grains/.meta/example.php   | 15 +++++
 exercises/practice/grains/Grains.php          | 15 +++++
 exercises/practice/grains/GrainsTest.php      | 15 +++++
 exercises/practice/hamming/.meta/example.php  | 15 +++++
 exercises/practice/hamming/Hamming.php        | 15 +++++
 exercises/practice/hamming/HammingTest.php    | 15 +++++
 .../practice/hello-world/.meta/example.php    | 15 +++++
 exercises/practice/hello-world/HelloWorld.php | 15 +++++
 .../practice/hello-world/HelloWorldTest.php   | 15 +++++
 exercises/practice/isogram/.meta/example.php  | 15 +++++
 exercises/practice/isogram/Isogram.php        | 15 +++++
 exercises/practice/isogram/IsogramTest.php    | 15 +++++
 .../largest-series-product/.meta/example.php  | 15 +++++
 .../LargestSeriesProduct.php                  | 15 +++++
 .../LargestSeriesProductTest.php              | 15 +++++
 exercises/practice/leap/.meta/example.php     | 15 +++++
 exercises/practice/leap/Leap.php              | 15 +++++
 exercises/practice/leap/LeapTest.php          | 15 +++++
 exercises/practice/luhn/.meta/example.php     | 15 +++++
 exercises/practice/luhn/Luhn.php              | 15 +++++
 exercises/practice/luhn/LuhnTest.php          | 15 +++++
 exercises/practice/markdown/.meta/example.php | 15 +++++
 exercises/practice/markdown/Markdown.php      | 15 +++++
 exercises/practice/markdown/MarkdownTest.php  | 15 +++++
 .../mask-credit-card/.meta/example.php        | 15 +++++
 .../mask-credit-card/MaskCreditCard.php       | 15 +++++
 .../mask-credit-card/MaskCreditCardTest.php   | 15 +++++
 .../matching-brackets/.meta/example.php       | 15 +++++
 .../matching-brackets/MatchingBrackets.php    | 15 +++++
 .../MatchingBracketsTest.php                  | 15 +++++
 exercises/practice/meetup/.meta/example.php   | 15 +++++
 exercises/practice/meetup/Meetup.php          | 15 +++++
 exercises/practice/meetup/MeetupTest.php      | 15 +++++
 .../practice/minesweeper/.meta/example.php    | 15 +++++
 .../practice/minesweeper/Minesweeper.php      | 15 +++++
 .../practice/minesweeper/MinesweeperTest.php  | 15 +++++
 .../practice/nth-prime/.meta/example.php      | 15 +++++
 exercises/practice/nth-prime/NthPrime.php     | 15 +++++
 exercises/practice/nth-prime/NthPrimeTest.php | 15 +++++
 .../nucleotide-count/.meta/example.php        | 15 +++++
 .../nucleotide-count/NucleotideCount.php      | 15 +++++
 .../nucleotide-count/NucleotideCountTest.php  | 15 +++++
 .../practice/ocr-numbers/.meta/example.php    | 15 +++++
 exercises/practice/ocr-numbers/OcrNumbers.php | 15 +++++
 .../practice/ocr-numbers/OcrNumbersTest.php   | 15 +++++
 .../practice/ordinal-number/.meta/example.php | 15 +++++
 .../practice/ordinal-number/OrdinalNumber.php | 15 +++++
 .../ordinal-number/OrdinalNumberTest.php      | 15 +++++
 .../palindrome-products/.meta/example.php     | 15 +++++
 .../PalindromeProducts.php                    | 15 +++++
 .../PalindromeProductsTest.php                | 15 +++++
 exercises/practice/pangram/.meta/example.php  | 15 +++++
 exercises/practice/pangram/Pangram.php        | 15 +++++
 exercises/practice/pangram/PangramTest.php    | 15 +++++
 .../pascals-triangle/.meta/example.php        | 15 +++++
 .../pascals-triangle/PascalsTriangle.php      | 15 +++++
 .../pascals-triangle/PascalsTriangleTest.php  | 15 +++++
 .../perfect-numbers/.meta/example.php         | 15 +++++
 .../perfect-numbers/PerfectNumbers.php        | 15 +++++
 .../perfect-numbers/PerfectNumbersTest.php    | 15 +++++
 .../practice/phone-number/.meta/example.php   | 15 +++++
 .../practice/phone-number/PhoneNumber.php     | 15 +++++
 .../practice/phone-number/PhoneNumberTest.php | 15 +++++
 .../practice/pig-latin/.meta/example.php      | 15 +++++
 exercises/practice/pig-latin/PigLatin.php     | 15 +++++
 exercises/practice/pig-latin/PigLatinTest.php | 15 +++++
 .../practice/prime-factors/.meta/example.php  | 15 +++++
 .../practice/prime-factors/PrimeFactors.php   | 15 +++++
 .../prime-factors/PrimeFactorsTest.php        | 15 +++++
 .../practice/queen-attack/.meta/example.php   | 15 +++++
 .../practice/queen-attack/QueenAttack.php     | 15 +++++
 .../practice/queen-attack/QueenAttackTest.php | 15 +++++
 .../rail-fence-cipher/.meta/example.php       | 15 +++++
 .../rail-fence-cipher/RailFenceCipher.php     | 15 +++++
 .../rail-fence-cipher/RailFenceCipherTest.php | 15 +++++
 .../practice/raindrops/.meta/example.php      | 15 +++++
 exercises/practice/raindrops/Raindrops.php    | 15 +++++
 .../practice/raindrops/RaindropsTest.php      | 15 +++++
 .../rna-transcription/.meta/example.php       | 15 +++++
 .../rna-transcription/RnaTranscription.php    | 15 +++++
 .../RnaTranscriptionTest.php                  | 15 +++++
 .../practice/robot-name/.meta/example.php     | 15 +++++
 exercises/practice/robot-name/RobotName.php   | 15 +++++
 .../practice/robot-name/RobotNameTest.php     | 15 +++++
 .../robot-simulator/.meta/example.php         | 15 +++++
 .../robot-simulator/RobotSimulator.php        | 15 +++++
 .../robot-simulator/RobotSimulatorTest.php    | 15 +++++
 .../practice/roman-numerals/.meta/example.php | 15 +++++
 .../practice/roman-numerals/RomanNumerals.php | 15 +++++
 .../roman-numerals/RomanNumeralsTest.php      | 15 +++++
 .../run-length-encoding/.meta/example.php     | 15 +++++
 .../run-length-encoding/RunLengthEncoding.php | 15 +++++
 .../RunLengthEncodingTest.php                 | 15 +++++
 .../practice/scrabble-score/.meta/example.php | 15 +++++
 .../practice/scrabble-score/ScrabbleScore.php | 15 +++++
 .../scrabble-score/ScrabbleScoreTest.php      | 15 +++++
 exercises/practice/series/.meta/example.php   | 15 +++++
 exercises/practice/series/Series.php          | 15 +++++
 exercises/practice/series/SeriesTest.php      | 15 +++++
 exercises/practice/sieve/.meta/example.php    | 15 +++++
 exercises/practice/sieve/Sieve.php            | 15 +++++
 exercises/practice/sieve/SieveTest.php        | 15 +++++
 .../practice/space-age/.meta/example.php      | 15 +++++
 exercises/practice/space-age/SpaceAge.php     | 15 +++++
 exercises/practice/space-age/SpaceAgeTest.php | 15 +++++
 .../sum-of-multiples/.meta/example.php        | 15 +++++
 .../sum-of-multiples/SumOfMultiples.php       | 15 +++++
 .../sum-of-multiples/SumOfMultiplesTest.php   | 15 +++++
 .../practice/transpose/.meta/example.php      | 15 +++++
 exercises/practice/transpose/Transpose.php    | 15 +++++
 .../practice/transpose/TransposeTest.php      | 15 +++++
 exercises/practice/triangle/.meta/example.php | 15 +++++
 exercises/practice/triangle/Triangle.php      | 15 +++++
 exercises/practice/triangle/TriangleTest.php  | 15 +++++
 exercises/practice/trinary/.meta/example.php  | 15 +++++
 exercises/practice/trinary/Trinary.php        | 15 +++++
 exercises/practice/trinary/TrinaryTest.php    | 15 +++++
 exercises/practice/two-fer/.meta/example.php  | 15 +++++
 exercises/practice/two-fer/TwoFer.php         | 15 +++++
 exercises/practice/two-fer/TwoFerTest.php     | 15 +++++
 .../.meta/example.php                         | 15 +++++
 .../VariableLengthQuantity.php                | 15 +++++
 .../VariableLengthQuantityTest.php            | 15 +++++
 .../practice/word-count/.meta/example.php     | 15 +++++
 exercises/practice/word-count/WordCount.php   | 15 +++++
 .../practice/word-count/WordCountTest.php     | 15 +++++
 exercises/practice/wordy/.meta/example.php    | 15 +++++
 exercises/practice/wordy/Wordy.php            | 15 +++++
 exercises/practice/wordy/WordyTest.php        | 15 +++++
 phpcs-php.xml                                 |  3 +-
 src/Sniffs/ExplainStrictTypesSniff.php        | 63 +++++++++++++++++++
 206 files changed, 3125 insertions(+), 1 deletion(-)
 create mode 100644 src/Sniffs/ExplainStrictTypesSniff.php

diff --git a/exercises/practice/accumulate/.meta/example.php b/exercises/practice/accumulate/.meta/example.php
index 0f48fbfb..a34ba434 100644
--- a/exercises/practice/accumulate/.meta/example.php
+++ b/exercises/practice/accumulate/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/accumulate/Accumulate.php b/exercises/practice/accumulate/Accumulate.php
index 1eb96ea8..4a3e7fef 100644
--- a/exercises/practice/accumulate/Accumulate.php
+++ b/exercises/practice/accumulate/Accumulate.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function accumulate(array $input, callable $accumulator): array
diff --git a/exercises/practice/accumulate/AccumulateTest.php b/exercises/practice/accumulate/AccumulateTest.php
index 4102aaa7..3c9762a9 100644
--- a/exercises/practice/accumulate/AccumulateTest.php
+++ b/exercises/practice/accumulate/AccumulateTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class AccumulateTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/acronym/.meta/example.php b/exercises/practice/acronym/.meta/example.php
index f7b4970e..8a4522c7 100644
--- a/exercises/practice/acronym/.meta/example.php
+++ b/exercises/practice/acronym/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/acronym/Acronym.php b/exercises/practice/acronym/Acronym.php
index f7b0bf9f..973e6ab7 100644
--- a/exercises/practice/acronym/Acronym.php
+++ b/exercises/practice/acronym/Acronym.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function acronym(string $text): string
diff --git a/exercises/practice/acronym/AcronymTest.php b/exercises/practice/acronym/AcronymTest.php
index 38972b13..367dc3aa 100644
--- a/exercises/practice/acronym/AcronymTest.php
+++ b/exercises/practice/acronym/AcronymTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class AcronymTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/affine-cipher/.meta/example.php b/exercises/practice/affine-cipher/.meta/example.php
index 5cb352c9..9c628b9d 100644
--- a/exercises/practice/affine-cipher/.meta/example.php
+++ b/exercises/practice/affine-cipher/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode($text, $a, $b)
diff --git a/exercises/practice/affine-cipher/AffineCipher.php b/exercises/practice/affine-cipher/AffineCipher.php
index 2e0fd494..8c544612 100644
--- a/exercises/practice/affine-cipher/AffineCipher.php
+++ b/exercises/practice/affine-cipher/AffineCipher.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode(string $text, int $num1, int $num2): string
diff --git a/exercises/practice/affine-cipher/AffineCipherTest.php b/exercises/practice/affine-cipher/AffineCipherTest.php
index 82592e84..e05bc2a8 100644
--- a/exercises/practice/affine-cipher/AffineCipherTest.php
+++ b/exercises/practice/affine-cipher/AffineCipherTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/all-your-base/.meta/example.php b/exercises/practice/all-your-base/.meta/example.php
index cdc9e131..cc2697e7 100644
--- a/exercises/practice/all-your-base/.meta/example.php
+++ b/exercises/practice/all-your-base/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function rebase(int $fromBase, array $digits, int $toBase)
diff --git a/exercises/practice/all-your-base/AllYourBase.php b/exercises/practice/all-your-base/AllYourBase.php
index 3be20c68..486f5e28 100644
--- a/exercises/practice/all-your-base/AllYourBase.php
+++ b/exercises/practice/all-your-base/AllYourBase.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function rebase(int $number, array $sequence, int $base)
diff --git a/exercises/practice/all-your-base/AllYourBaseTest.php b/exercises/practice/all-your-base/AllYourBaseTest.php
index eeae5b82..0292d955 100644
--- a/exercises/practice/all-your-base/AllYourBaseTest.php
+++ b/exercises/practice/all-your-base/AllYourBaseTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/allergies/.meta/example.php b/exercises/practice/allergies/.meta/example.php
index 97c7f3d0..5954c6b8 100644
--- a/exercises/practice/allergies/.meta/example.php
+++ b/exercises/practice/allergies/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Allergies
diff --git a/exercises/practice/allergies/Allergies.php b/exercises/practice/allergies/Allergies.php
index 1cf036bf..96e487c5 100644
--- a/exercises/practice/allergies/Allergies.php
+++ b/exercises/practice/allergies/Allergies.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Allergies
diff --git a/exercises/practice/allergies/AllergiesTest.php b/exercises/practice/allergies/AllergiesTest.php
index ce19101a..24b32b8d 100644
--- a/exercises/practice/allergies/AllergiesTest.php
+++ b/exercises/practice/allergies/AllergiesTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class AllergiesTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/anagram/.meta/example.php b/exercises/practice/anagram/.meta/example.php
index a6a97f5f..76500f45 100644
--- a/exercises/practice/anagram/.meta/example.php
+++ b/exercises/practice/anagram/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function detectAnagrams($anagram, array $possibleMatches)
diff --git a/exercises/practice/anagram/Anagram.php b/exercises/practice/anagram/Anagram.php
index f7e185df..1f31685d 100644
--- a/exercises/practice/anagram/Anagram.php
+++ b/exercises/practice/anagram/Anagram.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function detectAnagrams(string $word, array $anagrams): array
diff --git a/exercises/practice/anagram/AnagramTest.php b/exercises/practice/anagram/AnagramTest.php
index 823ab267..289b0aa1 100644
--- a/exercises/practice/anagram/AnagramTest.php
+++ b/exercises/practice/anagram/AnagramTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class AnagramTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/armstrong-numbers/.meta/example.php b/exercises/practice/armstrong-numbers/.meta/example.php
index b091bcea..650cc73c 100644
--- a/exercises/practice/armstrong-numbers/.meta/example.php
+++ b/exercises/practice/armstrong-numbers/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isArmstrongNumber(int $number): bool
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
index affb3747..96b4aa22 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isArmstrongNumber(int $number): bool
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
index 19baf1e0..59977e54 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class ArmstrongNumbersTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/atbash-cipher/.meta/example.php b/exercises/practice/atbash-cipher/.meta/example.php
index 2b850cf6..53d08b46 100644
--- a/exercises/practice/atbash-cipher/.meta/example.php
+++ b/exercises/practice/atbash-cipher/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode($string)
diff --git a/exercises/practice/atbash-cipher/AtbashCipher.php b/exercises/practice/atbash-cipher/AtbashCipher.php
index 767d2d68..8f6d9269 100644
--- a/exercises/practice/atbash-cipher/AtbashCipher.php
+++ b/exercises/practice/atbash-cipher/AtbashCipher.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode(string $text): string
diff --git a/exercises/practice/atbash-cipher/AtbashCipherTest.php b/exercises/practice/atbash-cipher/AtbashCipherTest.php
index dac714b8..b037d745 100644
--- a/exercises/practice/atbash-cipher/AtbashCipherTest.php
+++ b/exercises/practice/atbash-cipher/AtbashCipherTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class AtbashCipherTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/beer-song/.meta/example.php b/exercises/practice/beer-song/.meta/example.php
index 6342c2e7..bb5a316a 100644
--- a/exercises/practice/beer-song/.meta/example.php
+++ b/exercises/practice/beer-song/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BeerSong
diff --git a/exercises/practice/beer-song/BeerSong.php b/exercises/practice/beer-song/BeerSong.php
index 42a25770..10d717fd 100644
--- a/exercises/practice/beer-song/BeerSong.php
+++ b/exercises/practice/beer-song/BeerSong.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BeerSong
diff --git a/exercises/practice/beer-song/BeerSongTest.php b/exercises/practice/beer-song/BeerSongTest.php
index e0711360..5e6b41ed 100644
--- a/exercises/practice/beer-song/BeerSongTest.php
+++ b/exercises/practice/beer-song/BeerSongTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BeerSongTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/binary-search/.meta/example.php b/exercises/practice/binary-search/.meta/example.php
index 79cf0b31..8bc5c11c 100644
--- a/exercises/practice/binary-search/.meta/example.php
+++ b/exercises/practice/binary-search/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function find($needle, $haystack)
diff --git a/exercises/practice/binary-search/BinarySearch.php b/exercises/practice/binary-search/BinarySearch.php
index 294b965f..a1ace749 100644
--- a/exercises/practice/binary-search/BinarySearch.php
+++ b/exercises/practice/binary-search/BinarySearch.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function find(int $needle, array $haystack): int
diff --git a/exercises/practice/binary-search/BinarySearchTest.php b/exercises/practice/binary-search/BinarySearchTest.php
index 73482289..24d01823 100644
--- a/exercises/practice/binary-search/BinarySearchTest.php
+++ b/exercises/practice/binary-search/BinarySearchTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BinarySearchTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/binary/.meta/example.php b/exercises/practice/binary/.meta/example.php
index 2b2a3a6e..355092bb 100644
--- a/exercises/practice/binary/.meta/example.php
+++ b/exercises/practice/binary/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/binary/Binary.php b/exercises/practice/binary/Binary.php
index 46558fea..b096a3e6 100644
--- a/exercises/practice/binary/Binary.php
+++ b/exercises/practice/binary/Binary.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function parse_binary(string $binary): int
diff --git a/exercises/practice/binary/BinaryTest.php b/exercises/practice/binary/BinaryTest.php
index 53435a24..fe24e5aa 100644
--- a/exercises/practice/binary/BinaryTest.php
+++ b/exercises/practice/binary/BinaryTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BinaryTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/bob/.meta/example.php b/exercises/practice/bob/.meta/example.php
index 50217a45..0ac1b8c0 100644
--- a/exercises/practice/bob/.meta/example.php
+++ b/exercises/practice/bob/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Bob
diff --git a/exercises/practice/bob/Bob.php b/exercises/practice/bob/Bob.php
index 7e237b21..7600c843 100644
--- a/exercises/practice/bob/Bob.php
+++ b/exercises/practice/bob/Bob.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Bob
diff --git a/exercises/practice/bob/BobTest.php b/exercises/practice/bob/BobTest.php
index 7450dde4..effb299e 100644
--- a/exercises/practice/bob/BobTest.php
+++ b/exercises/practice/bob/BobTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class BobTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/book-store/.meta/example.php b/exercises/practice/book-store/.meta/example.php
index 2f451373..f174ca25 100644
--- a/exercises/practice/book-store/.meta/example.php
+++ b/exercises/practice/book-store/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function total($items)
diff --git a/exercises/practice/book-store/BookStore.php b/exercises/practice/book-store/BookStore.php
index 113a3c84..09cfc9e4 100644
--- a/exercises/practice/book-store/BookStore.php
+++ b/exercises/practice/book-store/BookStore.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function total(array $items): float
diff --git a/exercises/practice/book-store/BookStoreTest.php b/exercises/practice/book-store/BookStoreTest.php
index 873ed7a4..69e926d3 100644
--- a/exercises/practice/book-store/BookStoreTest.php
+++ b/exercises/practice/book-store/BookStoreTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/bowling/.meta/example.php b/exercises/practice/bowling/.meta/example.php
index 803b74e4..21f097dc 100644
--- a/exercises/practice/bowling/.meta/example.php
+++ b/exercises/practice/bowling/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/bowling/Bowling.php b/exercises/practice/bowling/Bowling.php
index 87b75937..6cd84d32 100644
--- a/exercises/practice/bowling/Bowling.php
+++ b/exercises/practice/bowling/Bowling.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Game
diff --git a/exercises/practice/bowling/BowlingTest.php b/exercises/practice/bowling/BowlingTest.php
index 965e812b..7b9cb543 100644
--- a/exercises/practice/bowling/BowlingTest.php
+++ b/exercises/practice/bowling/BowlingTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/change/.meta/example.php b/exercises/practice/change/.meta/example.php
index 35cdcce4..0de576e3 100644
--- a/exercises/practice/change/.meta/example.php
+++ b/exercises/practice/change/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 // adapted from the python example
diff --git a/exercises/practice/change/Change.php b/exercises/practice/change/Change.php
index 6612208b..f98824d3 100644
--- a/exercises/practice/change/Change.php
+++ b/exercises/practice/change/Change.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function findFewestCoins(array $coins, int $amount): array
diff --git a/exercises/practice/change/ChangeTest.php b/exercises/practice/change/ChangeTest.php
index 38498fbd..13e7cf05 100644
--- a/exercises/practice/change/ChangeTest.php
+++ b/exercises/practice/change/ChangeTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class ChangeTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/clock/.meta/example.php b/exercises/practice/clock/.meta/example.php
index 09d2a3c3..f3c0343a 100644
--- a/exercises/practice/clock/.meta/example.php
+++ b/exercises/practice/clock/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Clock
diff --git a/exercises/practice/clock/Clock.php b/exercises/practice/clock/Clock.php
index 7b861530..5e83b98b 100644
--- a/exercises/practice/clock/Clock.php
+++ b/exercises/practice/clock/Clock.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Clock
diff --git a/exercises/practice/clock/ClockTest.php b/exercises/practice/clock/ClockTest.php
index 6d4da74d..c505a2e6 100644
--- a/exercises/practice/clock/ClockTest.php
+++ b/exercises/practice/clock/ClockTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class ClockTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/collatz-conjecture/.meta/example.php b/exercises/practice/collatz-conjecture/.meta/example.php
index bcce0527..f1486b0a 100644
--- a/exercises/practice/collatz-conjecture/.meta/example.php
+++ b/exercises/practice/collatz-conjecture/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function steps($number)
diff --git a/exercises/practice/collatz-conjecture/CollatzConjecture.php b/exercises/practice/collatz-conjecture/CollatzConjecture.php
index 4b1d00ed..16f977ec 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjecture.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjecture.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function steps(int $number): int
diff --git a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
index d8e6a89c..68b96685 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class CollatzConjectureTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/connect/.meta/example.php b/exercises/practice/connect/.meta/example.php
index 28d53331..ba1fba63 100644
--- a/exercises/practice/connect/.meta/example.php
+++ b/exercises/practice/connect/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 const NOTHING = 0;
diff --git a/exercises/practice/connect/Connect.php b/exercises/practice/connect/Connect.php
index 5001c793..fcb628cf 100644
--- a/exercises/practice/connect/Connect.php
+++ b/exercises/practice/connect/Connect.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function resultFor(array $lines)
diff --git a/exercises/practice/connect/ConnectTest.php b/exercises/practice/connect/ConnectTest.php
index e3a8ee1e..649ec97c 100644
--- a/exercises/practice/connect/ConnectTest.php
+++ b/exercises/practice/connect/ConnectTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class ConnectTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/crypto-square/.meta/example.php b/exercises/practice/crypto-square/.meta/example.php
index 98cedcf5..6831b024 100644
--- a/exercises/practice/crypto-square/.meta/example.php
+++ b/exercises/practice/crypto-square/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function crypto_square($plaintext)
diff --git a/exercises/practice/crypto-square/CryptoSquare.php b/exercises/practice/crypto-square/CryptoSquare.php
index f431fea5..69bc3298 100644
--- a/exercises/practice/crypto-square/CryptoSquare.php
+++ b/exercises/practice/crypto-square/CryptoSquare.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function crypto_square(string $plaintext): string
diff --git a/exercises/practice/crypto-square/CryptoSquareTest.php b/exercises/practice/crypto-square/CryptoSquareTest.php
index e089536b..9e33de96 100644
--- a/exercises/practice/crypto-square/CryptoSquareTest.php
+++ b/exercises/practice/crypto-square/CryptoSquareTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class CryptoSquareTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/diamond/.meta/example.php b/exercises/practice/diamond/.meta/example.php
index 87348afe..0bf9700f 100644
--- a/exercises/practice/diamond/.meta/example.php
+++ b/exercises/practice/diamond/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function diamond($limit)
diff --git a/exercises/practice/diamond/Diamond.php b/exercises/practice/diamond/Diamond.php
index 127b243e..e12c7ff8 100644
--- a/exercises/practice/diamond/Diamond.php
+++ b/exercises/practice/diamond/Diamond.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function diamond(string $letter): array
diff --git a/exercises/practice/diamond/DiamondTest.php b/exercises/practice/diamond/DiamondTest.php
index 17c17020..739f767b 100644
--- a/exercises/practice/diamond/DiamondTest.php
+++ b/exercises/practice/diamond/DiamondTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class DiamondTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/difference-of-squares/.meta/example.php b/exercises/practice/difference-of-squares/.meta/example.php
index b05919fe..63fe5f28 100644
--- a/exercises/practice/difference-of-squares/.meta/example.php
+++ b/exercises/practice/difference-of-squares/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function squareOfSum($max)
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquares.php b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
index 29a7f2bc..243d1e86 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquares.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function squareOfSum(int $max): int
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
index f2bbc0ef..2c705269 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class DifferenceOfSquaresTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/etl/.meta/example.php b/exercises/practice/etl/.meta/example.php
index fe137af5..088e7009 100644
--- a/exercises/practice/etl/.meta/example.php
+++ b/exercises/practice/etl/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function transform($old)
diff --git a/exercises/practice/etl/Etl.php b/exercises/practice/etl/Etl.php
index 6cda93d8..86bd6550 100644
--- a/exercises/practice/etl/Etl.php
+++ b/exercises/practice/etl/Etl.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function transform(array $input): array
diff --git a/exercises/practice/etl/EtlTest.php b/exercises/practice/etl/EtlTest.php
index 70976129..72a64ea3 100644
--- a/exercises/practice/etl/EtlTest.php
+++ b/exercises/practice/etl/EtlTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class EtlTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/flatten-array/.meta/example.php b/exercises/practice/flatten-array/.meta/example.php
index 02aa7751..2f6171bc 100644
--- a/exercises/practice/flatten-array/.meta/example.php
+++ b/exercises/practice/flatten-array/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function flatten($array = [])
diff --git a/exercises/practice/flatten-array/FlattenArray.php b/exercises/practice/flatten-array/FlattenArray.php
index 3b956c21..9d856402 100644
--- a/exercises/practice/flatten-array/FlattenArray.php
+++ b/exercises/practice/flatten-array/FlattenArray.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function flatten(array $input): array
diff --git a/exercises/practice/flatten-array/FlattenArrayTest.php b/exercises/practice/flatten-array/FlattenArrayTest.php
index b2c9ca72..b261dbe7 100644
--- a/exercises/practice/flatten-array/FlattenArrayTest.php
+++ b/exercises/practice/flatten-array/FlattenArrayTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class FlattenArrayTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/gigasecond/.meta/example.php b/exercises/practice/gigasecond/.meta/example.php
index 2605fd82..d8b35948 100644
--- a/exercises/practice/gigasecond/.meta/example.php
+++ b/exercises/practice/gigasecond/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function from(DateTimeImmutable $from): DateTimeImmutable
diff --git a/exercises/practice/gigasecond/Gigasecond.php b/exercises/practice/gigasecond/Gigasecond.php
index b063058b..cedcad66 100644
--- a/exercises/practice/gigasecond/Gigasecond.php
+++ b/exercises/practice/gigasecond/Gigasecond.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function from(DateTimeImmutable $date): DateTimeImmutable
diff --git a/exercises/practice/gigasecond/GigasecondTest.php b/exercises/practice/gigasecond/GigasecondTest.php
index 27323ac0..57614f59 100644
--- a/exercises/practice/gigasecond/GigasecondTest.php
+++ b/exercises/practice/gigasecond/GigasecondTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class GigasecondTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/grade-school/.meta/example.php b/exercises/practice/grade-school/.meta/example.php
index 2cc5b463..740f70e9 100644
--- a/exercises/practice/grade-school/.meta/example.php
+++ b/exercises/practice/grade-school/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class School
diff --git a/exercises/practice/grade-school/GradeSchool.php b/exercises/practice/grade-school/GradeSchool.php
index 8adde9d6..aa6e7055 100644
--- a/exercises/practice/grade-school/GradeSchool.php
+++ b/exercises/practice/grade-school/GradeSchool.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class School
diff --git a/exercises/practice/grade-school/GradeSchoolTest.php b/exercises/practice/grade-school/GradeSchoolTest.php
index da50f748..3de8320e 100644
--- a/exercises/practice/grade-school/GradeSchoolTest.php
+++ b/exercises/practice/grade-school/GradeSchoolTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 use PHPUnit\Framework\TestCase;
diff --git a/exercises/practice/grains/.meta/example.php b/exercises/practice/grains/.meta/example.php
index 926c8466..ff0edd3f 100644
--- a/exercises/practice/grains/.meta/example.php
+++ b/exercises/practice/grains/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/grains/Grains.php b/exercises/practice/grains/Grains.php
index c7f46793..f9d71519 100644
--- a/exercises/practice/grains/Grains.php
+++ b/exercises/practice/grains/Grains.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function square(int $number): string
diff --git a/exercises/practice/grains/GrainsTest.php b/exercises/practice/grains/GrainsTest.php
index ab0c41da..4c84a879 100644
--- a/exercises/practice/grains/GrainsTest.php
+++ b/exercises/practice/grains/GrainsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class GrainsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/hamming/.meta/example.php b/exercises/practice/hamming/.meta/example.php
index 3aebbb0e..91d67816 100644
--- a/exercises/practice/hamming/.meta/example.php
+++ b/exercises/practice/hamming/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/hamming/Hamming.php b/exercises/practice/hamming/Hamming.php
index 1673019c..b99da3ff 100644
--- a/exercises/practice/hamming/Hamming.php
+++ b/exercises/practice/hamming/Hamming.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function distance(string $strandA, string $strandB): int
diff --git a/exercises/practice/hamming/HammingTest.php b/exercises/practice/hamming/HammingTest.php
index 48c603ab..bd21a30a 100644
--- a/exercises/practice/hamming/HammingTest.php
+++ b/exercises/practice/hamming/HammingTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class HammingTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/hello-world/.meta/example.php b/exercises/practice/hello-world/.meta/example.php
index 29eab547..e5b2b807 100644
--- a/exercises/practice/hello-world/.meta/example.php
+++ b/exercises/practice/hello-world/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function helloWorld($name = 'World')
diff --git a/exercises/practice/hello-world/HelloWorld.php b/exercises/practice/hello-world/HelloWorld.php
index f8cc37f0..34754a78 100644
--- a/exercises/practice/hello-world/HelloWorld.php
+++ b/exercises/practice/hello-world/HelloWorld.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 //
diff --git a/exercises/practice/hello-world/HelloWorldTest.php b/exercises/practice/hello-world/HelloWorldTest.php
index 35f51af5..22d82c71 100644
--- a/exercises/practice/hello-world/HelloWorldTest.php
+++ b/exercises/practice/hello-world/HelloWorldTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class HelloWorldTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/isogram/.meta/example.php b/exercises/practice/isogram/.meta/example.php
index 1f9aec0f..2cb88755 100644
--- a/exercises/practice/isogram/.meta/example.php
+++ b/exercises/practice/isogram/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isIsogram($string)
diff --git a/exercises/practice/isogram/Isogram.php b/exercises/practice/isogram/Isogram.php
index 6e33091c..9fcd10c6 100644
--- a/exercises/practice/isogram/Isogram.php
+++ b/exercises/practice/isogram/Isogram.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isogram(string $word): bool
diff --git a/exercises/practice/isogram/IsogramTest.php b/exercises/practice/isogram/IsogramTest.php
index 316895eb..6195554b 100644
--- a/exercises/practice/isogram/IsogramTest.php
+++ b/exercises/practice/isogram/IsogramTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class IsogramTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/largest-series-product/.meta/example.php b/exercises/practice/largest-series-product/.meta/example.php
index 7cf24696..ec29f6a9 100644
--- a/exercises/practice/largest-series-product/.meta/example.php
+++ b/exercises/practice/largest-series-product/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Series
diff --git a/exercises/practice/largest-series-product/LargestSeriesProduct.php b/exercises/practice/largest-series-product/LargestSeriesProduct.php
index 354266b4..7491ec6c 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProduct.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProduct.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Series
diff --git a/exercises/practice/largest-series-product/LargestSeriesProductTest.php b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
index 627dadba..50b27c76 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProductTest.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class LargestSeriesProductTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/leap/.meta/example.php b/exercises/practice/leap/.meta/example.php
index 66fdd6e3..ce666fa9 100644
--- a/exercises/practice/leap/.meta/example.php
+++ b/exercises/practice/leap/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/leap/Leap.php b/exercises/practice/leap/Leap.php
index 621c3149..f8ace236 100644
--- a/exercises/practice/leap/Leap.php
+++ b/exercises/practice/leap/Leap.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isLeap(int $year): bool
diff --git a/exercises/practice/leap/LeapTest.php b/exercises/practice/leap/LeapTest.php
index 7c7f622c..885dcda1 100644
--- a/exercises/practice/leap/LeapTest.php
+++ b/exercises/practice/leap/LeapTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class LeapTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/luhn/.meta/example.php b/exercises/practice/luhn/.meta/example.php
index 40ba888e..9cd040ba 100644
--- a/exercises/practice/luhn/.meta/example.php
+++ b/exercises/practice/luhn/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isValid($candidate)
diff --git a/exercises/practice/luhn/Luhn.php b/exercises/practice/luhn/Luhn.php
index 41867cbe..03fdc566 100644
--- a/exercises/practice/luhn/Luhn.php
+++ b/exercises/practice/luhn/Luhn.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isValid(string $number): bool
diff --git a/exercises/practice/luhn/LuhnTest.php b/exercises/practice/luhn/LuhnTest.php
index 4acc639a..3a797200 100644
--- a/exercises/practice/luhn/LuhnTest.php
+++ b/exercises/practice/luhn/LuhnTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class LuhnTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/markdown/.meta/example.php b/exercises/practice/markdown/.meta/example.php
index b1f1fdd2..7d7b798a 100644
--- a/exercises/practice/markdown/.meta/example.php
+++ b/exercises/practice/markdown/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function parseMarkdown($markdown)
diff --git a/exercises/practice/markdown/Markdown.php b/exercises/practice/markdown/Markdown.php
index a0ab8173..a5eb18da 100644
--- a/exercises/practice/markdown/Markdown.php
+++ b/exercises/practice/markdown/Markdown.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function parseMarkdown($markdown)
diff --git a/exercises/practice/markdown/MarkdownTest.php b/exercises/practice/markdown/MarkdownTest.php
index 8c39caa9..5334f08d 100644
--- a/exercises/practice/markdown/MarkdownTest.php
+++ b/exercises/practice/markdown/MarkdownTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class MarkdownTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/mask-credit-card/.meta/example.php b/exercises/practice/mask-credit-card/.meta/example.php
index 75ce376b..0f2b467f 100644
--- a/exercises/practice/mask-credit-card/.meta/example.php
+++ b/exercises/practice/mask-credit-card/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function maskify(string $cc): string
diff --git a/exercises/practice/mask-credit-card/MaskCreditCard.php b/exercises/practice/mask-credit-card/MaskCreditCard.php
index e00446b8..dbef46b9 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCard.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCard.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function maskify(string $cc): string
diff --git a/exercises/practice/mask-credit-card/MaskCreditCardTest.php b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
index 44b1af93..dd45c5a0 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCardTest.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class MaskCreditCardTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/matching-brackets/.meta/example.php b/exercises/practice/matching-brackets/.meta/example.php
index 4f5eb59d..18cf85f0 100644
--- a/exercises/practice/matching-brackets/.meta/example.php
+++ b/exercises/practice/matching-brackets/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function brackets_match(string $input): bool
diff --git a/exercises/practice/matching-brackets/MatchingBrackets.php b/exercises/practice/matching-brackets/MatchingBrackets.php
index 3c0490e6..6d4948e4 100644
--- a/exercises/practice/matching-brackets/MatchingBrackets.php
+++ b/exercises/practice/matching-brackets/MatchingBrackets.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function brackets_match(string $input): bool
diff --git a/exercises/practice/matching-brackets/MatchingBracketsTest.php b/exercises/practice/matching-brackets/MatchingBracketsTest.php
index ec8ae9be..5e713a55 100644
--- a/exercises/practice/matching-brackets/MatchingBracketsTest.php
+++ b/exercises/practice/matching-brackets/MatchingBracketsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class MatchingBracketsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/meetup/.meta/example.php b/exercises/practice/meetup/.meta/example.php
index f44574d8..c546f7e1 100644
--- a/exercises/practice/meetup/.meta/example.php
+++ b/exercises/practice/meetup/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function meetup_day($year, $month, $which, $weekday)
diff --git a/exercises/practice/meetup/Meetup.php b/exercises/practice/meetup/Meetup.php
index 3457c466..cd32ddbd 100644
--- a/exercises/practice/meetup/Meetup.php
+++ b/exercises/practice/meetup/Meetup.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function meetup_day(int $year, int $month, string $which, string $weekday): DateTimeImmutable
diff --git a/exercises/practice/meetup/MeetupTest.php b/exercises/practice/meetup/MeetupTest.php
index 63bf00ab..03c27ce1 100644
--- a/exercises/practice/meetup/MeetupTest.php
+++ b/exercises/practice/meetup/MeetupTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class MeetupTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/minesweeper/.meta/example.php b/exercises/practice/minesweeper/.meta/example.php
index 07414f57..4cf1adc6 100644
--- a/exercises/practice/minesweeper/.meta/example.php
+++ b/exercises/practice/minesweeper/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function solve($minesweeperBoard)
diff --git a/exercises/practice/minesweeper/Minesweeper.php b/exercises/practice/minesweeper/Minesweeper.php
index 74c323d4..7d01154d 100644
--- a/exercises/practice/minesweeper/Minesweeper.php
+++ b/exercises/practice/minesweeper/Minesweeper.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function solve(string $minesweeperBoard): string
diff --git a/exercises/practice/minesweeper/MinesweeperTest.php b/exercises/practice/minesweeper/MinesweeperTest.php
index 4a3dd549..0e000938 100644
--- a/exercises/practice/minesweeper/MinesweeperTest.php
+++ b/exercises/practice/minesweeper/MinesweeperTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class MinesweeperTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/nth-prime/.meta/example.php b/exercises/practice/nth-prime/.meta/example.php
index 5b31af6f..a852346b 100644
--- a/exercises/practice/nth-prime/.meta/example.php
+++ b/exercises/practice/nth-prime/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function prime($count)
diff --git a/exercises/practice/nth-prime/NthPrime.php b/exercises/practice/nth-prime/NthPrime.php
index 1a26c360..b5440472 100644
--- a/exercises/practice/nth-prime/NthPrime.php
+++ b/exercises/practice/nth-prime/NthPrime.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function prime(int $number)
diff --git a/exercises/practice/nth-prime/NthPrimeTest.php b/exercises/practice/nth-prime/NthPrimeTest.php
index 722cf92d..586ef52f 100644
--- a/exercises/practice/nth-prime/NthPrimeTest.php
+++ b/exercises/practice/nth-prime/NthPrimeTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class NthPrimeTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/nucleotide-count/.meta/example.php b/exercises/practice/nucleotide-count/.meta/example.php
index 494a44ea..b0dbbc1b 100644
--- a/exercises/practice/nucleotide-count/.meta/example.php
+++ b/exercises/practice/nucleotide-count/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function nucleotideCount($dna)
diff --git a/exercises/practice/nucleotide-count/NucleotideCount.php b/exercises/practice/nucleotide-count/NucleotideCount.php
index cf952273..e6e597ec 100644
--- a/exercises/practice/nucleotide-count/NucleotideCount.php
+++ b/exercises/practice/nucleotide-count/NucleotideCount.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function nucleotideCount(string $input): array
diff --git a/exercises/practice/nucleotide-count/NucleotideCountTest.php b/exercises/practice/nucleotide-count/NucleotideCountTest.php
index ef84d286..cd6bdbc4 100644
--- a/exercises/practice/nucleotide-count/NucleotideCountTest.php
+++ b/exercises/practice/nucleotide-count/NucleotideCountTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class NucleotideCountTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/ocr-numbers/.meta/example.php b/exercises/practice/ocr-numbers/.meta/example.php
index 8e6e6193..43163988 100644
--- a/exercises/practice/ocr-numbers/.meta/example.php
+++ b/exercises/practice/ocr-numbers/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function recognize($ocr)
diff --git a/exercises/practice/ocr-numbers/OcrNumbers.php b/exercises/practice/ocr-numbers/OcrNumbers.php
index 6bc59bac..bdf1bddb 100644
--- a/exercises/practice/ocr-numbers/OcrNumbers.php
+++ b/exercises/practice/ocr-numbers/OcrNumbers.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function recognize(array $input): string
diff --git a/exercises/practice/ocr-numbers/OcrNumbersTest.php b/exercises/practice/ocr-numbers/OcrNumbersTest.php
index 65551f05..cd9c137d 100644
--- a/exercises/practice/ocr-numbers/OcrNumbersTest.php
+++ b/exercises/practice/ocr-numbers/OcrNumbersTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class OcrNumbersTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/ordinal-number/.meta/example.php b/exercises/practice/ordinal-number/.meta/example.php
index 2b60c128..b0cc8da7 100644
--- a/exercises/practice/ordinal-number/.meta/example.php
+++ b/exercises/practice/ordinal-number/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toOrdinal(int $number): string
diff --git a/exercises/practice/ordinal-number/OrdinalNumber.php b/exercises/practice/ordinal-number/OrdinalNumber.php
index 84a29d57..dcb8f057 100644
--- a/exercises/practice/ordinal-number/OrdinalNumber.php
+++ b/exercises/practice/ordinal-number/OrdinalNumber.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toOrdinal(int $number): string
diff --git a/exercises/practice/ordinal-number/OrdinalNumberTest.php b/exercises/practice/ordinal-number/OrdinalNumberTest.php
index 2f6447b6..9214aa40 100644
--- a/exercises/practice/ordinal-number/OrdinalNumberTest.php
+++ b/exercises/practice/ordinal-number/OrdinalNumberTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class OrdinalNumberTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/palindrome-products/.meta/example.php b/exercises/practice/palindrome-products/.meta/example.php
index c036c83c..bfdc77eb 100644
--- a/exercises/practice/palindrome-products/.meta/example.php
+++ b/exercises/practice/palindrome-products/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function generatePalindromeProduct(array $range): ?int
diff --git a/exercises/practice/palindrome-products/PalindromeProducts.php b/exercises/practice/palindrome-products/PalindromeProducts.php
index e141cd55..7c677fa2 100644
--- a/exercises/practice/palindrome-products/PalindromeProducts.php
+++ b/exercises/practice/palindrome-products/PalindromeProducts.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function smallest(int $min, int $max): array
diff --git a/exercises/practice/palindrome-products/PalindromeProductsTest.php b/exercises/practice/palindrome-products/PalindromeProductsTest.php
index 2629d841..d3771c03 100644
--- a/exercises/practice/palindrome-products/PalindromeProductsTest.php
+++ b/exercises/practice/palindrome-products/PalindromeProductsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PalindromeProductsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/pangram/.meta/example.php b/exercises/practice/pangram/.meta/example.php
index 319c6b9d..dc4b23da 100644
--- a/exercises/practice/pangram/.meta/example.php
+++ b/exercises/practice/pangram/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isPangram($string)
diff --git a/exercises/practice/pangram/Pangram.php b/exercises/practice/pangram/Pangram.php
index ff2a60f6..434e7769 100644
--- a/exercises/practice/pangram/Pangram.php
+++ b/exercises/practice/pangram/Pangram.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function isPangram(string $string): bool
diff --git a/exercises/practice/pangram/PangramTest.php b/exercises/practice/pangram/PangramTest.php
index ea1ab227..a5ba551c 100644
--- a/exercises/practice/pangram/PangramTest.php
+++ b/exercises/practice/pangram/PangramTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PangramTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/pascals-triangle/.meta/example.php b/exercises/practice/pascals-triangle/.meta/example.php
index da7c2825..6586d37a 100644
--- a/exercises/practice/pascals-triangle/.meta/example.php
+++ b/exercises/practice/pascals-triangle/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function pascalsTriangleRows($rowCount)
diff --git a/exercises/practice/pascals-triangle/PascalsTriangle.php b/exercises/practice/pascals-triangle/PascalsTriangle.php
index 62a4266d..0a67e4fb 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangle.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangle.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function pascalsTriangleRows(int $rowCount)
diff --git a/exercises/practice/pascals-triangle/PascalsTriangleTest.php b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
index 8af62b88..f1a4ab8b 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangleTest.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PascalsTriangleTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/perfect-numbers/.meta/example.php b/exercises/practice/perfect-numbers/.meta/example.php
index 4556f648..aa043c15 100644
--- a/exercises/practice/perfect-numbers/.meta/example.php
+++ b/exercises/practice/perfect-numbers/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function getClassification($number)
diff --git a/exercises/practice/perfect-numbers/PerfectNumbers.php b/exercises/practice/perfect-numbers/PerfectNumbers.php
index b30baeac..40bb47b7 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbers.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbers.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function getClassification(int $number): string
diff --git a/exercises/practice/perfect-numbers/PerfectNumbersTest.php b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
index 9a11f736..fc569bfc 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbersTest.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PerfectNumbersTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/phone-number/.meta/example.php b/exercises/practice/phone-number/.meta/example.php
index c7dbc536..eb3bd3a4 100644
--- a/exercises/practice/phone-number/.meta/example.php
+++ b/exercises/practice/phone-number/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PhoneNumber
diff --git a/exercises/practice/phone-number/PhoneNumber.php b/exercises/practice/phone-number/PhoneNumber.php
index c3ff1bc0..5b1f6493 100644
--- a/exercises/practice/phone-number/PhoneNumber.php
+++ b/exercises/practice/phone-number/PhoneNumber.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PhoneNumber
diff --git a/exercises/practice/phone-number/PhoneNumberTest.php b/exercises/practice/phone-number/PhoneNumberTest.php
index e0bac93f..e93fdeb5 100644
--- a/exercises/practice/phone-number/PhoneNumberTest.php
+++ b/exercises/practice/phone-number/PhoneNumberTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PhoneNumberTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/pig-latin/.meta/example.php b/exercises/practice/pig-latin/.meta/example.php
index 32e73112..94f24d75 100644
--- a/exercises/practice/pig-latin/.meta/example.php
+++ b/exercises/practice/pig-latin/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/pig-latin/PigLatin.php b/exercises/practice/pig-latin/PigLatin.php
index e7f1e08d..c197fee2 100644
--- a/exercises/practice/pig-latin/PigLatin.php
+++ b/exercises/practice/pig-latin/PigLatin.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function translate(string $text): string
diff --git a/exercises/practice/pig-latin/PigLatinTest.php b/exercises/practice/pig-latin/PigLatinTest.php
index 2acca732..35805a27 100644
--- a/exercises/practice/pig-latin/PigLatinTest.php
+++ b/exercises/practice/pig-latin/PigLatinTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PigLatinTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/prime-factors/.meta/example.php b/exercises/practice/prime-factors/.meta/example.php
index 90198824..d04fdce3 100644
--- a/exercises/practice/prime-factors/.meta/example.php
+++ b/exercises/practice/prime-factors/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function factors($n)
diff --git a/exercises/practice/prime-factors/PrimeFactors.php b/exercises/practice/prime-factors/PrimeFactors.php
index 157b9ffa..be39f715 100644
--- a/exercises/practice/prime-factors/PrimeFactors.php
+++ b/exercises/practice/prime-factors/PrimeFactors.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function factors(int $number): array
diff --git a/exercises/practice/prime-factors/PrimeFactorsTest.php b/exercises/practice/prime-factors/PrimeFactorsTest.php
index 3e36b54a..aae838e1 100644
--- a/exercises/practice/prime-factors/PrimeFactorsTest.php
+++ b/exercises/practice/prime-factors/PrimeFactorsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class PrimeFactorsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/queen-attack/.meta/example.php b/exercises/practice/queen-attack/.meta/example.php
index 9ebf1680..ec56f2aa 100644
--- a/exercises/practice/queen-attack/.meta/example.php
+++ b/exercises/practice/queen-attack/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/queen-attack/QueenAttack.php b/exercises/practice/queen-attack/QueenAttack.php
index 0df82d15..1520a8d4 100644
--- a/exercises/practice/queen-attack/QueenAttack.php
+++ b/exercises/practice/queen-attack/QueenAttack.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function placeQueen(int $xCoordinate, int $yCoordinate): bool
diff --git a/exercises/practice/queen-attack/QueenAttackTest.php b/exercises/practice/queen-attack/QueenAttackTest.php
index e45f148c..8b177917 100644
--- a/exercises/practice/queen-attack/QueenAttackTest.php
+++ b/exercises/practice/queen-attack/QueenAttackTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class QueenAttackTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/rail-fence-cipher/.meta/example.php b/exercises/practice/rail-fence-cipher/.meta/example.php
index 59b31b8c..ef378d66 100644
--- a/exercises/practice/rail-fence-cipher/.meta/example.php
+++ b/exercises/practice/rail-fence-cipher/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode($plainMessage, $rails)
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipher.php b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
index 5e7d9792..74f9879d 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipher.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode(string $plainMessage, int $rails): string
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
index 773e5964..7b4a4c3f 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RailFenceCipherTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/raindrops/.meta/example.php b/exercises/practice/raindrops/.meta/example.php
index 35cc7b45..534c6414 100644
--- a/exercises/practice/raindrops/.meta/example.php
+++ b/exercises/practice/raindrops/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function raindrops($num)
diff --git a/exercises/practice/raindrops/Raindrops.php b/exercises/practice/raindrops/Raindrops.php
index 8ae5a187..d1f7c00a 100644
--- a/exercises/practice/raindrops/Raindrops.php
+++ b/exercises/practice/raindrops/Raindrops.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function raindrops(int $number): string
diff --git a/exercises/practice/raindrops/RaindropsTest.php b/exercises/practice/raindrops/RaindropsTest.php
index 9f1a0804..1bfbb1c2 100644
--- a/exercises/practice/raindrops/RaindropsTest.php
+++ b/exercises/practice/raindrops/RaindropsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RaindropsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/rna-transcription/.meta/example.php b/exercises/practice/rna-transcription/.meta/example.php
index 3f29623f..69981b21 100644
--- a/exercises/practice/rna-transcription/.meta/example.php
+++ b/exercises/practice/rna-transcription/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toRna($strand)
diff --git a/exercises/practice/rna-transcription/RnaTranscription.php b/exercises/practice/rna-transcription/RnaTranscription.php
index de76cccf..ea11ce77 100644
--- a/exercises/practice/rna-transcription/RnaTranscription.php
+++ b/exercises/practice/rna-transcription/RnaTranscription.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toRna(string $dna): string
diff --git a/exercises/practice/rna-transcription/RnaTranscriptionTest.php b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
index fb5b15b8..e58ad49a 100644
--- a/exercises/practice/rna-transcription/RnaTranscriptionTest.php
+++ b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RnaTranscriptionTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/robot-name/.meta/example.php b/exercises/practice/robot-name/.meta/example.php
index 1839f132..38ffc4ca 100644
--- a/exercises/practice/robot-name/.meta/example.php
+++ b/exercises/practice/robot-name/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Robot
diff --git a/exercises/practice/robot-name/RobotName.php b/exercises/practice/robot-name/RobotName.php
index 72a64768..72cce3e7 100644
--- a/exercises/practice/robot-name/RobotName.php
+++ b/exercises/practice/robot-name/RobotName.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Robot
diff --git a/exercises/practice/robot-name/RobotNameTest.php b/exercises/practice/robot-name/RobotNameTest.php
index 83ab4fb5..5b938dbf 100644
--- a/exercises/practice/robot-name/RobotNameTest.php
+++ b/exercises/practice/robot-name/RobotNameTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RobotNameTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/robot-simulator/.meta/example.php b/exercises/practice/robot-simulator/.meta/example.php
index 3fa032ab..f0409b19 100644
--- a/exercises/practice/robot-simulator/.meta/example.php
+++ b/exercises/practice/robot-simulator/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Robot
diff --git a/exercises/practice/robot-simulator/RobotSimulator.php b/exercises/practice/robot-simulator/RobotSimulator.php
index c878a25c..e0f4a0fb 100644
--- a/exercises/practice/robot-simulator/RobotSimulator.php
+++ b/exercises/practice/robot-simulator/RobotSimulator.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Robot
diff --git a/exercises/practice/robot-simulator/RobotSimulatorTest.php b/exercises/practice/robot-simulator/RobotSimulatorTest.php
index f8f43a5a..79a43426 100644
--- a/exercises/practice/robot-simulator/RobotSimulatorTest.php
+++ b/exercises/practice/robot-simulator/RobotSimulatorTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RobotSimulatorTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/roman-numerals/.meta/example.php b/exercises/practice/roman-numerals/.meta/example.php
index 5335bf92..50272032 100644
--- a/exercises/practice/roman-numerals/.meta/example.php
+++ b/exercises/practice/roman-numerals/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toRoman($number)
diff --git a/exercises/practice/roman-numerals/RomanNumerals.php b/exercises/practice/roman-numerals/RomanNumerals.php
index 598bd7bb..988076e3 100644
--- a/exercises/practice/roman-numerals/RomanNumerals.php
+++ b/exercises/practice/roman-numerals/RomanNumerals.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toRoman(int $number): string
diff --git a/exercises/practice/roman-numerals/RomanNumeralsTest.php b/exercises/practice/roman-numerals/RomanNumeralsTest.php
index f68e037d..65a9e9e4 100644
--- a/exercises/practice/roman-numerals/RomanNumeralsTest.php
+++ b/exercises/practice/roman-numerals/RomanNumeralsTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RomanNumeralsTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/run-length-encoding/.meta/example.php b/exercises/practice/run-length-encoding/.meta/example.php
index 2c0b7e8c..13f8818e 100644
--- a/exercises/practice/run-length-encoding/.meta/example.php
+++ b/exercises/practice/run-length-encoding/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/run-length-encoding/RunLengthEncoding.php b/exercises/practice/run-length-encoding/RunLengthEncoding.php
index 2a8559b8..f5da4539 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncoding.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncoding.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function encode(string $input): string
diff --git a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
index 98ea0abd..00e6de01 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class RunLengthEncodingTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/scrabble-score/.meta/example.php b/exercises/practice/scrabble-score/.meta/example.php
index 9df33e2e..d90292b8 100644
--- a/exercises/practice/scrabble-score/.meta/example.php
+++ b/exercises/practice/scrabble-score/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function score($word)
diff --git a/exercises/practice/scrabble-score/ScrabbleScore.php b/exercises/practice/scrabble-score/ScrabbleScore.php
index 325716ef..c51b12a2 100644
--- a/exercises/practice/scrabble-score/ScrabbleScore.php
+++ b/exercises/practice/scrabble-score/ScrabbleScore.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function score(string $word): int
diff --git a/exercises/practice/scrabble-score/ScrabbleScoreTest.php b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
index a51a0234..cdacea69 100644
--- a/exercises/practice/scrabble-score/ScrabbleScoreTest.php
+++ b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/series/.meta/example.php b/exercises/practice/series/.meta/example.php
index 096d7685..0d4b5467 100644
--- a/exercises/practice/series/.meta/example.php
+++ b/exercises/practice/series/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function slices($series, $size)
diff --git a/exercises/practice/series/Series.php b/exercises/practice/series/Series.php
index 78d61def..240c3a4b 100644
--- a/exercises/practice/series/Series.php
+++ b/exercises/practice/series/Series.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function slices(string $digits, int $series): array
diff --git a/exercises/practice/series/SeriesTest.php b/exercises/practice/series/SeriesTest.php
index d3b21e6c..8483a85a 100644
--- a/exercises/practice/series/SeriesTest.php
+++ b/exercises/practice/series/SeriesTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SeriesTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/sieve/.meta/example.php b/exercises/practice/sieve/.meta/example.php
index f894eaa7..fe14aa3f 100644
--- a/exercises/practice/sieve/.meta/example.php
+++ b/exercises/practice/sieve/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function sieve($number)
diff --git a/exercises/practice/sieve/Sieve.php b/exercises/practice/sieve/Sieve.php
index 9e85a302..017eecde 100644
--- a/exercises/practice/sieve/Sieve.php
+++ b/exercises/practice/sieve/Sieve.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function sieve(int $number): array
diff --git a/exercises/practice/sieve/SieveTest.php b/exercises/practice/sieve/SieveTest.php
index ba58f409..72f577a0 100644
--- a/exercises/practice/sieve/SieveTest.php
+++ b/exercises/practice/sieve/SieveTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SieveTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/space-age/.meta/example.php b/exercises/practice/space-age/.meta/example.php
index 0f47f72a..7731a24c 100644
--- a/exercises/practice/space-age/.meta/example.php
+++ b/exercises/practice/space-age/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SpaceAge
diff --git a/exercises/practice/space-age/SpaceAge.php b/exercises/practice/space-age/SpaceAge.php
index 754f7582..544ee342 100644
--- a/exercises/practice/space-age/SpaceAge.php
+++ b/exercises/practice/space-age/SpaceAge.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SpaceAge
diff --git a/exercises/practice/space-age/SpaceAgeTest.php b/exercises/practice/space-age/SpaceAgeTest.php
index 67674917..18d91cbd 100644
--- a/exercises/practice/space-age/SpaceAgeTest.php
+++ b/exercises/practice/space-age/SpaceAgeTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SpaceAgeTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/sum-of-multiples/.meta/example.php b/exercises/practice/sum-of-multiples/.meta/example.php
index c796d15b..1f42073d 100644
--- a/exercises/practice/sum-of-multiples/.meta/example.php
+++ b/exercises/practice/sum-of-multiples/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function sumOfMultiples($number, $multiples)
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiples.php b/exercises/practice/sum-of-multiples/SumOfMultiples.php
index 96ec9a25..cb2df0d2 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiples.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiples.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function sumOfMultiples(int $number, array $multiples): int
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
index a35e623c..64f56bcd 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class SumOfMultiplesTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/transpose/.meta/example.php b/exercises/practice/transpose/.meta/example.php
index 6a133bca..35133f64 100644
--- a/exercises/practice/transpose/.meta/example.php
+++ b/exercises/practice/transpose/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/transpose/Transpose.php b/exercises/practice/transpose/Transpose.php
index f1839f39..aa324d0e 100644
--- a/exercises/practice/transpose/Transpose.php
+++ b/exercises/practice/transpose/Transpose.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function transpose(array $input): array
diff --git a/exercises/practice/transpose/TransposeTest.php b/exercises/practice/transpose/TransposeTest.php
index 99daff71..079050ad 100644
--- a/exercises/practice/transpose/TransposeTest.php
+++ b/exercises/practice/transpose/TransposeTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class TransposeTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/triangle/.meta/example.php b/exercises/practice/triangle/.meta/example.php
index fdf59a5a..7249cfd3 100644
--- a/exercises/practice/triangle/.meta/example.php
+++ b/exercises/practice/triangle/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Triangle
diff --git a/exercises/practice/triangle/Triangle.php b/exercises/practice/triangle/Triangle.php
index 6efe3b5b..acf60b4f 100644
--- a/exercises/practice/triangle/Triangle.php
+++ b/exercises/practice/triangle/Triangle.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class Triangle
diff --git a/exercises/practice/triangle/TriangleTest.php b/exercises/practice/triangle/TriangleTest.php
index ec9127c0..298e1129 100644
--- a/exercises/practice/triangle/TriangleTest.php
+++ b/exercises/practice/triangle/TriangleTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class TriangleTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/trinary/.meta/example.php b/exercises/practice/trinary/.meta/example.php
index 6a4b6745..47075281 100644
--- a/exercises/practice/trinary/.meta/example.php
+++ b/exercises/practice/trinary/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toDecimal($ternaryString, $base = 3)
diff --git a/exercises/practice/trinary/Trinary.php b/exercises/practice/trinary/Trinary.php
index e34acf50..0b37e714 100644
--- a/exercises/practice/trinary/Trinary.php
+++ b/exercises/practice/trinary/Trinary.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function toDecimal(string $number): int
diff --git a/exercises/practice/trinary/TrinaryTest.php b/exercises/practice/trinary/TrinaryTest.php
index fa328d42..14b69401 100644
--- a/exercises/practice/trinary/TrinaryTest.php
+++ b/exercises/practice/trinary/TrinaryTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class TrinaryTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/two-fer/.meta/example.php b/exercises/practice/two-fer/.meta/example.php
index 6a72f9c6..90042bdd 100644
--- a/exercises/practice/two-fer/.meta/example.php
+++ b/exercises/practice/two-fer/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function twoFer(string $name = 'you'): string
diff --git a/exercises/practice/two-fer/TwoFer.php b/exercises/practice/two-fer/TwoFer.php
index edd032fc..c8f2c05e 100644
--- a/exercises/practice/two-fer/TwoFer.php
+++ b/exercises/practice/two-fer/TwoFer.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function twoFer(string $name): string
diff --git a/exercises/practice/two-fer/TwoFerTest.php b/exercises/practice/two-fer/TwoFerTest.php
index 7ed0c297..6305f849 100644
--- a/exercises/practice/two-fer/TwoFerTest.php
+++ b/exercises/practice/two-fer/TwoFerTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class TwoFerTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/variable-length-quantity/.meta/example.php b/exercises/practice/variable-length-quantity/.meta/example.php
index 9dbfe63f..dafa1dae 100644
--- a/exercises/practice/variable-length-quantity/.meta/example.php
+++ b/exercises/practice/variable-length-quantity/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 /**
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
index 188592cf..456d73a1 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function vlq_encode(array $input): array
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
index bc8d0f7f..4649ba8a 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class VariableLengthQuantityTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/word-count/.meta/example.php b/exercises/practice/word-count/.meta/example.php
index ef4133bd..b7f5a908 100644
--- a/exercises/practice/word-count/.meta/example.php
+++ b/exercises/practice/word-count/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function wordCount($phrase)
diff --git a/exercises/practice/word-count/WordCount.php b/exercises/practice/word-count/WordCount.php
index 9e2e9f74..fc1a083e 100644
--- a/exercises/practice/word-count/WordCount.php
+++ b/exercises/practice/word-count/WordCount.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function wordCount(string $words): array
diff --git a/exercises/practice/word-count/WordCountTest.php b/exercises/practice/word-count/WordCountTest.php
index 6960f330..c8935b65 100644
--- a/exercises/practice/word-count/WordCountTest.php
+++ b/exercises/practice/word-count/WordCountTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class WordCountTest extends PHPUnit\Framework\TestCase
diff --git a/exercises/practice/wordy/.meta/example.php b/exercises/practice/wordy/.meta/example.php
index d5dc9e34..a7c143bf 100644
--- a/exercises/practice/wordy/.meta/example.php
+++ b/exercises/practice/wordy/.meta/example.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function calculate($question = "")
diff --git a/exercises/practice/wordy/Wordy.php b/exercises/practice/wordy/Wordy.php
index 77729e5a..f4edd1d9 100644
--- a/exercises/practice/wordy/Wordy.php
+++ b/exercises/practice/wordy/Wordy.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 function calculate(string $input): int
diff --git a/exercises/practice/wordy/WordyTest.php b/exercises/practice/wordy/WordyTest.php
index 77e49563..f1b4b3ba 100644
--- a/exercises/practice/wordy/WordyTest.php
+++ b/exercises/practice/wordy/WordyTest.php
@@ -1,5 +1,20 @@
 <?php
 
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+
 declare(strict_types=1);
 
 class WordyTest extends PHPUnit\Framework\TestCase
diff --git a/phpcs-php.xml b/phpcs-php.xml
index 3849bec7..5b99119f 100644
--- a/phpcs-php.xml
+++ b/phpcs-php.xml
@@ -10,8 +10,9 @@
   </rule>
   <rule ref="vendor/slevomat/coding-standard/SlevomatCodingStandard/Sniffs/TypeHints/DeclareStrictTypesSniff.php">
     <properties>
-      <property name="newlinesCountBetweenOpenTagAndDeclare" type="int" value="2" />
+      <property name="newlinesCountBetweenOpenTagAndDeclare" type="int" value="1" />
       <property name="spacesCountAroundEqualsSign" type="int" value="0" />
     </properties>
   </rule>
+  <rule ref="src/Sniffs/ExplainStrictTypesSniff.php"/>
 </ruleset>
diff --git a/src/Sniffs/ExplainStrictTypesSniff.php b/src/Sniffs/ExplainStrictTypesSniff.php
new file mode 100644
index 00000000..178acf14
--- /dev/null
+++ b/src/Sniffs/ExplainStrictTypesSniff.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Exercism\Php\Sniffs;
+
+use PHP_CodeSniffer\Files\File;
+use PHP_CodeSniffer\Fixer;
+use PHP_CodeSniffer\Sniffs\Sniff;
+
+class ExplainStrictTypesSniff implements Sniff
+{
+    private static string $explanation = <<<EOT
+/*
+ * By adding type hints and enabling strict type checking, code can become easier to read,
+ * self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict,
+ * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * In other words, if you pass a string to a function requiring a float,
+ * it will attempt to convert the string value to a float.
+ * To enable strict mode, a single declare directive must be placed at the top of the file.
+ * This means that the strictness of typing is configured on a per-file basis.
+ * This directive not only affects the type declarations of parameters, but also a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track <link>.
+ * To disable strict typing, comment out the directive below.
+ */
+EOT;
+
+    private ?Fixer $fixer = null;
+    private int $position = 0;
+
+    private array $tokens = [
+        T_COMMENT,
+    ];
+
+    public function register(): array
+    {
+        return [
+            T_DECLARE,
+        ];
+    }
+
+    public function process(File $file, $stackPtr)
+    {
+        $this->fixer = $file->fixer;
+        $this->position = $stackPtr;
+
+        if (!$file->findPrevious($this->tokens, $stackPtr)) {
+            $file->addFixableError(
+                'Missing explanation of declaration of strict types.',
+                $stackPtr - 1,
+                self::class
+            );
+            $this->fix();
+        }
+    }
+
+    private function fix(): void
+    {
+        $this->fixer->addContent($this->position - 1, self::$explanation);
+    }
+}

From 4f441252042b48c9d14ae70e5d595c0d95eb3f15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Sun, 27 Jun 2021 18:14:06 +0200
Subject: [PATCH 6/8] Enforce php versions

---
 composer.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/composer.json b/composer.json
index e7f24976..a601bf74 100644
--- a/composer.json
+++ b/composer.json
@@ -5,6 +5,7 @@
     "Exercism\\Exercises\\": "exercises"
   },
   "require-dev": {
+    "php": "^7.4|^8.0",
     "slevomat/coding-standard": "^7.0",
     "squizlabs/php_codesniffer": "^3.6"
   },

From 4dc2def56056bbf025847a92cd05a7a346d8e847 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Mon, 28 Jun 2021 22:48:07 +0200
Subject: [PATCH 7/8] Try to fix comment to be justifed

---
 exercises/practice/accumulate/.meta/example.php          | 7 ++++---
 exercises/practice/accumulate/Accumulate.php             | 7 ++++---
 exercises/practice/accumulate/AccumulateTest.php         | 7 ++++---
 exercises/practice/acronym/.meta/example.php             | 7 ++++---
 exercises/practice/acronym/Acronym.php                   | 7 ++++---
 exercises/practice/acronym/AcronymTest.php               | 7 ++++---
 exercises/practice/affine-cipher/.meta/example.php       | 7 ++++---
 exercises/practice/affine-cipher/AffineCipher.php        | 7 ++++---
 exercises/practice/affine-cipher/AffineCipherTest.php    | 7 ++++---
 exercises/practice/all-your-base/.meta/example.php       | 7 ++++---
 exercises/practice/all-your-base/AllYourBase.php         | 7 ++++---
 exercises/practice/all-your-base/AllYourBaseTest.php     | 7 ++++---
 exercises/practice/allergies/.meta/example.php           | 7 ++++---
 exercises/practice/allergies/Allergies.php               | 7 ++++---
 exercises/practice/allergies/AllergiesTest.php           | 7 ++++---
 exercises/practice/anagram/.meta/example.php             | 7 ++++---
 exercises/practice/anagram/Anagram.php                   | 7 ++++---
 exercises/practice/anagram/AnagramTest.php               | 7 ++++---
 exercises/practice/armstrong-numbers/.meta/example.php   | 7 ++++---
 .../practice/armstrong-numbers/ArmstrongNumbers.php      | 7 ++++---
 .../practice/armstrong-numbers/ArmstrongNumbersTest.php  | 7 ++++---
 exercises/practice/atbash-cipher/.meta/example.php       | 7 ++++---
 exercises/practice/atbash-cipher/AtbashCipher.php        | 7 ++++---
 exercises/practice/atbash-cipher/AtbashCipherTest.php    | 7 ++++---
 exercises/practice/beer-song/.meta/example.php           | 7 ++++---
 exercises/practice/beer-song/BeerSong.php                | 7 ++++---
 exercises/practice/beer-song/BeerSongTest.php            | 7 ++++---
 exercises/practice/binary-search/.meta/example.php       | 7 ++++---
 exercises/practice/binary-search/BinarySearch.php        | 7 ++++---
 exercises/practice/binary-search/BinarySearchTest.php    | 7 ++++---
 exercises/practice/binary/.meta/example.php              | 7 ++++---
 exercises/practice/binary/Binary.php                     | 7 ++++---
 exercises/practice/binary/BinaryTest.php                 | 7 ++++---
 exercises/practice/bob/.meta/example.php                 | 7 ++++---
 exercises/practice/bob/Bob.php                           | 7 ++++---
 exercises/practice/bob/BobTest.php                       | 7 ++++---
 exercises/practice/book-store/.meta/example.php          | 7 ++++---
 exercises/practice/book-store/BookStore.php              | 7 ++++---
 exercises/practice/book-store/BookStoreTest.php          | 7 ++++---
 exercises/practice/bowling/.meta/example.php             | 7 ++++---
 exercises/practice/bowling/Bowling.php                   | 7 ++++---
 exercises/practice/bowling/BowlingTest.php               | 7 ++++---
 exercises/practice/change/.meta/example.php              | 7 ++++---
 exercises/practice/change/Change.php                     | 7 ++++---
 exercises/practice/change/ChangeTest.php                 | 7 ++++---
 exercises/practice/clock/.meta/example.php               | 7 ++++---
 exercises/practice/clock/Clock.php                       | 7 ++++---
 exercises/practice/clock/ClockTest.php                   | 7 ++++---
 exercises/practice/collatz-conjecture/.meta/example.php  | 7 ++++---
 .../practice/collatz-conjecture/CollatzConjecture.php    | 7 ++++---
 .../collatz-conjecture/CollatzConjectureTest.php         | 7 ++++---
 exercises/practice/connect/.meta/example.php             | 7 ++++---
 exercises/practice/connect/Connect.php                   | 7 ++++---
 exercises/practice/connect/ConnectTest.php               | 7 ++++---
 exercises/practice/crypto-square/.meta/example.php       | 7 ++++---
 exercises/practice/crypto-square/CryptoSquare.php        | 7 ++++---
 exercises/practice/crypto-square/CryptoSquareTest.php    | 7 ++++---
 exercises/practice/diamond/.meta/example.php             | 7 ++++---
 exercises/practice/diamond/Diamond.php                   | 7 ++++---
 exercises/practice/diamond/DiamondTest.php               | 7 ++++---
 .../practice/difference-of-squares/.meta/example.php     | 7 ++++---
 .../difference-of-squares/DifferenceOfSquares.php        | 7 ++++---
 .../difference-of-squares/DifferenceOfSquaresTest.php    | 7 ++++---
 exercises/practice/etl/.meta/example.php                 | 7 ++++---
 exercises/practice/etl/Etl.php                           | 7 ++++---
 exercises/practice/etl/EtlTest.php                       | 7 ++++---
 exercises/practice/flatten-array/.meta/example.php       | 7 ++++---
 exercises/practice/flatten-array/FlattenArray.php        | 7 ++++---
 exercises/practice/flatten-array/FlattenArrayTest.php    | 7 ++++---
 exercises/practice/gigasecond/.meta/example.php          | 7 ++++---
 exercises/practice/gigasecond/Gigasecond.php             | 7 ++++---
 exercises/practice/gigasecond/GigasecondTest.php         | 7 ++++---
 exercises/practice/grade-school/.meta/example.php        | 7 ++++---
 exercises/practice/grade-school/GradeSchool.php          | 7 ++++---
 exercises/practice/grade-school/GradeSchoolTest.php      | 7 ++++---
 exercises/practice/grains/.meta/example.php              | 7 ++++---
 exercises/practice/grains/Grains.php                     | 7 ++++---
 exercises/practice/grains/GrainsTest.php                 | 7 ++++---
 exercises/practice/hamming/.meta/example.php             | 7 ++++---
 exercises/practice/hamming/Hamming.php                   | 7 ++++---
 exercises/practice/hamming/HammingTest.php               | 7 ++++---
 exercises/practice/hello-world/.meta/example.php         | 7 ++++---
 exercises/practice/hello-world/HelloWorld.php            | 7 ++++---
 exercises/practice/hello-world/HelloWorldTest.php        | 7 ++++---
 exercises/practice/isogram/.meta/example.php             | 7 ++++---
 exercises/practice/isogram/Isogram.php                   | 7 ++++---
 exercises/practice/isogram/IsogramTest.php               | 7 ++++---
 .../practice/largest-series-product/.meta/example.php    | 7 ++++---
 .../largest-series-product/LargestSeriesProduct.php      | 7 ++++---
 .../largest-series-product/LargestSeriesProductTest.php  | 7 ++++---
 exercises/practice/leap/.meta/example.php                | 7 ++++---
 exercises/practice/leap/Leap.php                         | 7 ++++---
 exercises/practice/leap/LeapTest.php                     | 7 ++++---
 exercises/practice/luhn/.meta/example.php                | 7 ++++---
 exercises/practice/luhn/Luhn.php                         | 7 ++++---
 exercises/practice/luhn/LuhnTest.php                     | 7 ++++---
 exercises/practice/markdown/.meta/example.php            | 7 ++++---
 exercises/practice/markdown/Markdown.php                 | 7 ++++---
 exercises/practice/markdown/MarkdownTest.php             | 7 ++++---
 exercises/practice/mask-credit-card/.meta/example.php    | 7 ++++---
 exercises/practice/mask-credit-card/MaskCreditCard.php   | 7 ++++---
 .../practice/mask-credit-card/MaskCreditCardTest.php     | 7 ++++---
 exercises/practice/matching-brackets/.meta/example.php   | 7 ++++---
 .../practice/matching-brackets/MatchingBrackets.php      | 7 ++++---
 .../practice/matching-brackets/MatchingBracketsTest.php  | 7 ++++---
 exercises/practice/meetup/.meta/example.php              | 7 ++++---
 exercises/practice/meetup/Meetup.php                     | 7 ++++---
 exercises/practice/meetup/MeetupTest.php                 | 7 ++++---
 exercises/practice/minesweeper/.meta/example.php         | 7 ++++---
 exercises/practice/minesweeper/Minesweeper.php           | 7 ++++---
 exercises/practice/minesweeper/MinesweeperTest.php       | 7 ++++---
 exercises/practice/nth-prime/.meta/example.php           | 7 ++++---
 exercises/practice/nth-prime/NthPrime.php                | 7 ++++---
 exercises/practice/nth-prime/NthPrimeTest.php            | 7 ++++---
 exercises/practice/nucleotide-count/.meta/example.php    | 7 ++++---
 exercises/practice/nucleotide-count/NucleotideCount.php  | 7 ++++---
 .../practice/nucleotide-count/NucleotideCountTest.php    | 7 ++++---
 exercises/practice/ocr-numbers/.meta/example.php         | 7 ++++---
 exercises/practice/ocr-numbers/OcrNumbers.php            | 7 ++++---
 exercises/practice/ocr-numbers/OcrNumbersTest.php        | 7 ++++---
 exercises/practice/ordinal-number/.meta/example.php      | 7 ++++---
 exercises/practice/ordinal-number/OrdinalNumber.php      | 7 ++++---
 exercises/practice/ordinal-number/OrdinalNumberTest.php  | 7 ++++---
 exercises/practice/palindrome-products/.meta/example.php | 7 ++++---
 .../practice/palindrome-products/PalindromeProducts.php  | 7 ++++---
 .../palindrome-products/PalindromeProductsTest.php       | 7 ++++---
 exercises/practice/pangram/.meta/example.php             | 7 ++++---
 exercises/practice/pangram/Pangram.php                   | 7 ++++---
 exercises/practice/pangram/PangramTest.php               | 7 ++++---
 exercises/practice/pascals-triangle/.meta/example.php    | 7 ++++---
 exercises/practice/pascals-triangle/PascalsTriangle.php  | 7 ++++---
 .../practice/pascals-triangle/PascalsTriangleTest.php    | 7 ++++---
 exercises/practice/perfect-numbers/.meta/example.php     | 7 ++++---
 exercises/practice/perfect-numbers/PerfectNumbers.php    | 7 ++++---
 .../practice/perfect-numbers/PerfectNumbersTest.php      | 7 ++++---
 exercises/practice/phone-number/.meta/example.php        | 7 ++++---
 exercises/practice/phone-number/PhoneNumber.php          | 7 ++++---
 exercises/practice/phone-number/PhoneNumberTest.php      | 7 ++++---
 exercises/practice/pig-latin/.meta/example.php           | 7 ++++---
 exercises/practice/pig-latin/PigLatin.php                | 7 ++++---
 exercises/practice/pig-latin/PigLatinTest.php            | 7 ++++---
 exercises/practice/prime-factors/.meta/example.php       | 7 ++++---
 exercises/practice/prime-factors/PrimeFactors.php        | 7 ++++---
 exercises/practice/prime-factors/PrimeFactorsTest.php    | 7 ++++---
 exercises/practice/queen-attack/.meta/example.php        | 7 ++++---
 exercises/practice/queen-attack/QueenAttack.php          | 7 ++++---
 exercises/practice/queen-attack/QueenAttackTest.php      | 7 ++++---
 exercises/practice/rail-fence-cipher/.meta/example.php   | 7 ++++---
 exercises/practice/rail-fence-cipher/RailFenceCipher.php | 7 ++++---
 .../practice/rail-fence-cipher/RailFenceCipherTest.php   | 7 ++++---
 exercises/practice/raindrops/.meta/example.php           | 7 ++++---
 exercises/practice/raindrops/Raindrops.php               | 7 ++++---
 exercises/practice/raindrops/RaindropsTest.php           | 7 ++++---
 exercises/practice/rna-transcription/.meta/example.php   | 7 ++++---
 .../practice/rna-transcription/RnaTranscription.php      | 7 ++++---
 .../practice/rna-transcription/RnaTranscriptionTest.php  | 7 ++++---
 exercises/practice/robot-name/.meta/example.php          | 7 ++++---
 exercises/practice/robot-name/RobotName.php              | 7 ++++---
 exercises/practice/robot-name/RobotNameTest.php          | 7 ++++---
 exercises/practice/robot-simulator/.meta/example.php     | 7 ++++---
 exercises/practice/robot-simulator/RobotSimulator.php    | 7 ++++---
 .../practice/robot-simulator/RobotSimulatorTest.php      | 7 ++++---
 exercises/practice/roman-numerals/.meta/example.php      | 7 ++++---
 exercises/practice/roman-numerals/RomanNumerals.php      | 7 ++++---
 exercises/practice/roman-numerals/RomanNumeralsTest.php  | 7 ++++---
 exercises/practice/run-length-encoding/.meta/example.php | 7 ++++---
 .../practice/run-length-encoding/RunLengthEncoding.php   | 7 ++++---
 .../run-length-encoding/RunLengthEncodingTest.php        | 7 ++++---
 exercises/practice/scrabble-score/.meta/example.php      | 7 ++++---
 exercises/practice/scrabble-score/ScrabbleScore.php      | 7 ++++---
 exercises/practice/scrabble-score/ScrabbleScoreTest.php  | 7 ++++---
 exercises/practice/series/.meta/example.php              | 7 ++++---
 exercises/practice/series/Series.php                     | 7 ++++---
 exercises/practice/series/SeriesTest.php                 | 7 ++++---
 exercises/practice/sieve/.meta/example.php               | 7 ++++---
 exercises/practice/sieve/Sieve.php                       | 7 ++++---
 exercises/practice/sieve/SieveTest.php                   | 7 ++++---
 exercises/practice/space-age/.meta/example.php           | 7 ++++---
 exercises/practice/space-age/SpaceAge.php                | 7 ++++---
 exercises/practice/space-age/SpaceAgeTest.php            | 7 ++++---
 exercises/practice/sum-of-multiples/.meta/example.php    | 7 ++++---
 exercises/practice/sum-of-multiples/SumOfMultiples.php   | 7 ++++---
 .../practice/sum-of-multiples/SumOfMultiplesTest.php     | 7 ++++---
 exercises/practice/transpose/.meta/example.php           | 7 ++++---
 exercises/practice/transpose/Transpose.php               | 7 ++++---
 exercises/practice/transpose/TransposeTest.php           | 7 ++++---
 exercises/practice/triangle/.meta/example.php            | 7 ++++---
 exercises/practice/triangle/Triangle.php                 | 7 ++++---
 exercises/practice/triangle/TriangleTest.php             | 7 ++++---
 exercises/practice/trinary/.meta/example.php             | 7 ++++---
 exercises/practice/trinary/Trinary.php                   | 7 ++++---
 exercises/practice/trinary/TrinaryTest.php               | 7 ++++---
 exercises/practice/two-fer/.meta/example.php             | 7 ++++---
 exercises/practice/two-fer/TwoFer.php                    | 7 ++++---
 exercises/practice/two-fer/TwoFerTest.php                | 7 ++++---
 .../practice/variable-length-quantity/.meta/example.php  | 7 ++++---
 .../variable-length-quantity/VariableLengthQuantity.php  | 7 ++++---
 .../VariableLengthQuantityTest.php                       | 7 ++++---
 exercises/practice/word-count/.meta/example.php          | 7 ++++---
 exercises/practice/word-count/WordCount.php              | 7 ++++---
 exercises/practice/word-count/WordCountTest.php          | 7 ++++---
 exercises/practice/wordy/.meta/example.php               | 7 ++++---
 exercises/practice/wordy/Wordy.php                       | 7 ++++---
 exercises/practice/wordy/WordyTest.php                   | 7 ++++---
 src/Sniffs/ExplainStrictTypesSniff.php                   | 9 +++++----
 205 files changed, 821 insertions(+), 616 deletions(-)

diff --git a/exercises/practice/accumulate/.meta/example.php b/exercises/practice/accumulate/.meta/example.php
index a34ba434..f2709268 100644
--- a/exercises/practice/accumulate/.meta/example.php
+++ b/exercises/practice/accumulate/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/accumulate/Accumulate.php b/exercises/practice/accumulate/Accumulate.php
index 4a3e7fef..f2a44f54 100644
--- a/exercises/practice/accumulate/Accumulate.php
+++ b/exercises/practice/accumulate/Accumulate.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/accumulate/AccumulateTest.php b/exercises/practice/accumulate/AccumulateTest.php
index 3c9762a9..c666bf67 100644
--- a/exercises/practice/accumulate/AccumulateTest.php
+++ b/exercises/practice/accumulate/AccumulateTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/acronym/.meta/example.php b/exercises/practice/acronym/.meta/example.php
index 8a4522c7..039ef4a3 100644
--- a/exercises/practice/acronym/.meta/example.php
+++ b/exercises/practice/acronym/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/acronym/Acronym.php b/exercises/practice/acronym/Acronym.php
index 973e6ab7..1f56606b 100644
--- a/exercises/practice/acronym/Acronym.php
+++ b/exercises/practice/acronym/Acronym.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/acronym/AcronymTest.php b/exercises/practice/acronym/AcronymTest.php
index 367dc3aa..f3626334 100644
--- a/exercises/practice/acronym/AcronymTest.php
+++ b/exercises/practice/acronym/AcronymTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/affine-cipher/.meta/example.php b/exercises/practice/affine-cipher/.meta/example.php
index 9c628b9d..1e1b4398 100644
--- a/exercises/practice/affine-cipher/.meta/example.php
+++ b/exercises/practice/affine-cipher/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/affine-cipher/AffineCipher.php b/exercises/practice/affine-cipher/AffineCipher.php
index 8c544612..056d57b5 100644
--- a/exercises/practice/affine-cipher/AffineCipher.php
+++ b/exercises/practice/affine-cipher/AffineCipher.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/affine-cipher/AffineCipherTest.php b/exercises/practice/affine-cipher/AffineCipherTest.php
index e05bc2a8..7eb88c75 100644
--- a/exercises/practice/affine-cipher/AffineCipherTest.php
+++ b/exercises/practice/affine-cipher/AffineCipherTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/all-your-base/.meta/example.php b/exercises/practice/all-your-base/.meta/example.php
index cc2697e7..c1711e90 100644
--- a/exercises/practice/all-your-base/.meta/example.php
+++ b/exercises/practice/all-your-base/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/all-your-base/AllYourBase.php b/exercises/practice/all-your-base/AllYourBase.php
index 486f5e28..a3cf642f 100644
--- a/exercises/practice/all-your-base/AllYourBase.php
+++ b/exercises/practice/all-your-base/AllYourBase.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/all-your-base/AllYourBaseTest.php b/exercises/practice/all-your-base/AllYourBaseTest.php
index 0292d955..d9891468 100644
--- a/exercises/practice/all-your-base/AllYourBaseTest.php
+++ b/exercises/practice/all-your-base/AllYourBaseTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/allergies/.meta/example.php b/exercises/practice/allergies/.meta/example.php
index 5954c6b8..e1cb39ce 100644
--- a/exercises/practice/allergies/.meta/example.php
+++ b/exercises/practice/allergies/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/allergies/Allergies.php b/exercises/practice/allergies/Allergies.php
index 96e487c5..24cd043a 100644
--- a/exercises/practice/allergies/Allergies.php
+++ b/exercises/practice/allergies/Allergies.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/allergies/AllergiesTest.php b/exercises/practice/allergies/AllergiesTest.php
index 24b32b8d..42fedf94 100644
--- a/exercises/practice/allergies/AllergiesTest.php
+++ b/exercises/practice/allergies/AllergiesTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/anagram/.meta/example.php b/exercises/practice/anagram/.meta/example.php
index 76500f45..80245d58 100644
--- a/exercises/practice/anagram/.meta/example.php
+++ b/exercises/practice/anagram/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/anagram/Anagram.php b/exercises/practice/anagram/Anagram.php
index 1f31685d..e7457aec 100644
--- a/exercises/practice/anagram/Anagram.php
+++ b/exercises/practice/anagram/Anagram.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/anagram/AnagramTest.php b/exercises/practice/anagram/AnagramTest.php
index 289b0aa1..5050fc0d 100644
--- a/exercises/practice/anagram/AnagramTest.php
+++ b/exercises/practice/anagram/AnagramTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/armstrong-numbers/.meta/example.php b/exercises/practice/armstrong-numbers/.meta/example.php
index 650cc73c..cfe68304 100644
--- a/exercises/practice/armstrong-numbers/.meta/example.php
+++ b/exercises/practice/armstrong-numbers/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
index 96b4aa22..538b15e8 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
index 59977e54..92899485 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/atbash-cipher/.meta/example.php b/exercises/practice/atbash-cipher/.meta/example.php
index 53d08b46..4ac371cb 100644
--- a/exercises/practice/atbash-cipher/.meta/example.php
+++ b/exercises/practice/atbash-cipher/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/atbash-cipher/AtbashCipher.php b/exercises/practice/atbash-cipher/AtbashCipher.php
index 8f6d9269..0e50bdb2 100644
--- a/exercises/practice/atbash-cipher/AtbashCipher.php
+++ b/exercises/practice/atbash-cipher/AtbashCipher.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/atbash-cipher/AtbashCipherTest.php b/exercises/practice/atbash-cipher/AtbashCipherTest.php
index b037d745..5d3a73ed 100644
--- a/exercises/practice/atbash-cipher/AtbashCipherTest.php
+++ b/exercises/practice/atbash-cipher/AtbashCipherTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/beer-song/.meta/example.php b/exercises/practice/beer-song/.meta/example.php
index bb5a316a..f8b8c5fd 100644
--- a/exercises/practice/beer-song/.meta/example.php
+++ b/exercises/practice/beer-song/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/beer-song/BeerSong.php b/exercises/practice/beer-song/BeerSong.php
index 10d717fd..5931ae2b 100644
--- a/exercises/practice/beer-song/BeerSong.php
+++ b/exercises/practice/beer-song/BeerSong.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/beer-song/BeerSongTest.php b/exercises/practice/beer-song/BeerSongTest.php
index 5e6b41ed..463501c9 100644
--- a/exercises/practice/beer-song/BeerSongTest.php
+++ b/exercises/practice/beer-song/BeerSongTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary-search/.meta/example.php b/exercises/practice/binary-search/.meta/example.php
index 8bc5c11c..832e45ad 100644
--- a/exercises/practice/binary-search/.meta/example.php
+++ b/exercises/practice/binary-search/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary-search/BinarySearch.php b/exercises/practice/binary-search/BinarySearch.php
index a1ace749..cda7c816 100644
--- a/exercises/practice/binary-search/BinarySearch.php
+++ b/exercises/practice/binary-search/BinarySearch.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary-search/BinarySearchTest.php b/exercises/practice/binary-search/BinarySearchTest.php
index 24d01823..7d090f37 100644
--- a/exercises/practice/binary-search/BinarySearchTest.php
+++ b/exercises/practice/binary-search/BinarySearchTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary/.meta/example.php b/exercises/practice/binary/.meta/example.php
index 355092bb..e541eff2 100644
--- a/exercises/practice/binary/.meta/example.php
+++ b/exercises/practice/binary/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary/Binary.php b/exercises/practice/binary/Binary.php
index b096a3e6..e236405f 100644
--- a/exercises/practice/binary/Binary.php
+++ b/exercises/practice/binary/Binary.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/binary/BinaryTest.php b/exercises/practice/binary/BinaryTest.php
index fe24e5aa..2f0719d2 100644
--- a/exercises/practice/binary/BinaryTest.php
+++ b/exercises/practice/binary/BinaryTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bob/.meta/example.php b/exercises/practice/bob/.meta/example.php
index 0ac1b8c0..09277a9b 100644
--- a/exercises/practice/bob/.meta/example.php
+++ b/exercises/practice/bob/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bob/Bob.php b/exercises/practice/bob/Bob.php
index 7600c843..b7e0ae32 100644
--- a/exercises/practice/bob/Bob.php
+++ b/exercises/practice/bob/Bob.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bob/BobTest.php b/exercises/practice/bob/BobTest.php
index effb299e..72c9eeee 100644
--- a/exercises/practice/bob/BobTest.php
+++ b/exercises/practice/bob/BobTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/book-store/.meta/example.php b/exercises/practice/book-store/.meta/example.php
index f174ca25..5aefe541 100644
--- a/exercises/practice/book-store/.meta/example.php
+++ b/exercises/practice/book-store/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/book-store/BookStore.php b/exercises/practice/book-store/BookStore.php
index 09cfc9e4..c66744a6 100644
--- a/exercises/practice/book-store/BookStore.php
+++ b/exercises/practice/book-store/BookStore.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/book-store/BookStoreTest.php b/exercises/practice/book-store/BookStoreTest.php
index 69e926d3..42c53f00 100644
--- a/exercises/practice/book-store/BookStoreTest.php
+++ b/exercises/practice/book-store/BookStoreTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bowling/.meta/example.php b/exercises/practice/bowling/.meta/example.php
index 21f097dc..4dfd736c 100644
--- a/exercises/practice/bowling/.meta/example.php
+++ b/exercises/practice/bowling/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bowling/Bowling.php b/exercises/practice/bowling/Bowling.php
index 6cd84d32..15a8fe0b 100644
--- a/exercises/practice/bowling/Bowling.php
+++ b/exercises/practice/bowling/Bowling.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/bowling/BowlingTest.php b/exercises/practice/bowling/BowlingTest.php
index 7b9cb543..3d13d175 100644
--- a/exercises/practice/bowling/BowlingTest.php
+++ b/exercises/practice/bowling/BowlingTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/change/.meta/example.php b/exercises/practice/change/.meta/example.php
index 0de576e3..251d9cb7 100644
--- a/exercises/practice/change/.meta/example.php
+++ b/exercises/practice/change/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/change/Change.php b/exercises/practice/change/Change.php
index f98824d3..f3c4f4d8 100644
--- a/exercises/practice/change/Change.php
+++ b/exercises/practice/change/Change.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/change/ChangeTest.php b/exercises/practice/change/ChangeTest.php
index 13e7cf05..7d417dfe 100644
--- a/exercises/practice/change/ChangeTest.php
+++ b/exercises/practice/change/ChangeTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/clock/.meta/example.php b/exercises/practice/clock/.meta/example.php
index f3c0343a..f430a264 100644
--- a/exercises/practice/clock/.meta/example.php
+++ b/exercises/practice/clock/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/clock/Clock.php b/exercises/practice/clock/Clock.php
index 5e83b98b..503daf42 100644
--- a/exercises/practice/clock/Clock.php
+++ b/exercises/practice/clock/Clock.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/clock/ClockTest.php b/exercises/practice/clock/ClockTest.php
index c505a2e6..1e27be5c 100644
--- a/exercises/practice/clock/ClockTest.php
+++ b/exercises/practice/clock/ClockTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/collatz-conjecture/.meta/example.php b/exercises/practice/collatz-conjecture/.meta/example.php
index f1486b0a..9f8364cd 100644
--- a/exercises/practice/collatz-conjecture/.meta/example.php
+++ b/exercises/practice/collatz-conjecture/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/collatz-conjecture/CollatzConjecture.php b/exercises/practice/collatz-conjecture/CollatzConjecture.php
index 16f977ec..f5f553ee 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjecture.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjecture.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
index 68b96685..b929e378 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/connect/.meta/example.php b/exercises/practice/connect/.meta/example.php
index ba1fba63..a01bf9f3 100644
--- a/exercises/practice/connect/.meta/example.php
+++ b/exercises/practice/connect/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/connect/Connect.php b/exercises/practice/connect/Connect.php
index fcb628cf..b6a3f773 100644
--- a/exercises/practice/connect/Connect.php
+++ b/exercises/practice/connect/Connect.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/connect/ConnectTest.php b/exercises/practice/connect/ConnectTest.php
index 649ec97c..dfc7ff1e 100644
--- a/exercises/practice/connect/ConnectTest.php
+++ b/exercises/practice/connect/ConnectTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/crypto-square/.meta/example.php b/exercises/practice/crypto-square/.meta/example.php
index 6831b024..a2ba582c 100644
--- a/exercises/practice/crypto-square/.meta/example.php
+++ b/exercises/practice/crypto-square/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/crypto-square/CryptoSquare.php b/exercises/practice/crypto-square/CryptoSquare.php
index 69bc3298..b33bb9fa 100644
--- a/exercises/practice/crypto-square/CryptoSquare.php
+++ b/exercises/practice/crypto-square/CryptoSquare.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/crypto-square/CryptoSquareTest.php b/exercises/practice/crypto-square/CryptoSquareTest.php
index 9e33de96..1c2ac23a 100644
--- a/exercises/practice/crypto-square/CryptoSquareTest.php
+++ b/exercises/practice/crypto-square/CryptoSquareTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/diamond/.meta/example.php b/exercises/practice/diamond/.meta/example.php
index 0bf9700f..a0c075d1 100644
--- a/exercises/practice/diamond/.meta/example.php
+++ b/exercises/practice/diamond/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/diamond/Diamond.php b/exercises/practice/diamond/Diamond.php
index e12c7ff8..ed4ce369 100644
--- a/exercises/practice/diamond/Diamond.php
+++ b/exercises/practice/diamond/Diamond.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/diamond/DiamondTest.php b/exercises/practice/diamond/DiamondTest.php
index 739f767b..54e66c63 100644
--- a/exercises/practice/diamond/DiamondTest.php
+++ b/exercises/practice/diamond/DiamondTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/difference-of-squares/.meta/example.php b/exercises/practice/difference-of-squares/.meta/example.php
index 63fe5f28..c4b2db15 100644
--- a/exercises/practice/difference-of-squares/.meta/example.php
+++ b/exercises/practice/difference-of-squares/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquares.php b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
index 243d1e86..ba5e8649 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquares.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
index 2c705269..acc329b1 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/etl/.meta/example.php b/exercises/practice/etl/.meta/example.php
index 088e7009..42386d0b 100644
--- a/exercises/practice/etl/.meta/example.php
+++ b/exercises/practice/etl/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/etl/Etl.php b/exercises/practice/etl/Etl.php
index 86bd6550..83672ea3 100644
--- a/exercises/practice/etl/Etl.php
+++ b/exercises/practice/etl/Etl.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/etl/EtlTest.php b/exercises/practice/etl/EtlTest.php
index 72a64ea3..fe686485 100644
--- a/exercises/practice/etl/EtlTest.php
+++ b/exercises/practice/etl/EtlTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/flatten-array/.meta/example.php b/exercises/practice/flatten-array/.meta/example.php
index 2f6171bc..e524d978 100644
--- a/exercises/practice/flatten-array/.meta/example.php
+++ b/exercises/practice/flatten-array/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/flatten-array/FlattenArray.php b/exercises/practice/flatten-array/FlattenArray.php
index 9d856402..51d21da9 100644
--- a/exercises/practice/flatten-array/FlattenArray.php
+++ b/exercises/practice/flatten-array/FlattenArray.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/flatten-array/FlattenArrayTest.php b/exercises/practice/flatten-array/FlattenArrayTest.php
index b261dbe7..f17d94f3 100644
--- a/exercises/practice/flatten-array/FlattenArrayTest.php
+++ b/exercises/practice/flatten-array/FlattenArrayTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/gigasecond/.meta/example.php b/exercises/practice/gigasecond/.meta/example.php
index d8b35948..a248ba33 100644
--- a/exercises/practice/gigasecond/.meta/example.php
+++ b/exercises/practice/gigasecond/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/gigasecond/Gigasecond.php b/exercises/practice/gigasecond/Gigasecond.php
index cedcad66..3aebebc2 100644
--- a/exercises/practice/gigasecond/Gigasecond.php
+++ b/exercises/practice/gigasecond/Gigasecond.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/gigasecond/GigasecondTest.php b/exercises/practice/gigasecond/GigasecondTest.php
index 57614f59..bf940227 100644
--- a/exercises/practice/gigasecond/GigasecondTest.php
+++ b/exercises/practice/gigasecond/GigasecondTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grade-school/.meta/example.php b/exercises/practice/grade-school/.meta/example.php
index 740f70e9..591cde41 100644
--- a/exercises/practice/grade-school/.meta/example.php
+++ b/exercises/practice/grade-school/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grade-school/GradeSchool.php b/exercises/practice/grade-school/GradeSchool.php
index aa6e7055..13aec8b8 100644
--- a/exercises/practice/grade-school/GradeSchool.php
+++ b/exercises/practice/grade-school/GradeSchool.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grade-school/GradeSchoolTest.php b/exercises/practice/grade-school/GradeSchoolTest.php
index 3de8320e..16e90915 100644
--- a/exercises/practice/grade-school/GradeSchoolTest.php
+++ b/exercises/practice/grade-school/GradeSchoolTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grains/.meta/example.php b/exercises/practice/grains/.meta/example.php
index ff0edd3f..40a2fb41 100644
--- a/exercises/practice/grains/.meta/example.php
+++ b/exercises/practice/grains/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grains/Grains.php b/exercises/practice/grains/Grains.php
index f9d71519..59b64fa8 100644
--- a/exercises/practice/grains/Grains.php
+++ b/exercises/practice/grains/Grains.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/grains/GrainsTest.php b/exercises/practice/grains/GrainsTest.php
index 4c84a879..a19cf68a 100644
--- a/exercises/practice/grains/GrainsTest.php
+++ b/exercises/practice/grains/GrainsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hamming/.meta/example.php b/exercises/practice/hamming/.meta/example.php
index 91d67816..152ecb92 100644
--- a/exercises/practice/hamming/.meta/example.php
+++ b/exercises/practice/hamming/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hamming/Hamming.php b/exercises/practice/hamming/Hamming.php
index b99da3ff..dfbccd52 100644
--- a/exercises/practice/hamming/Hamming.php
+++ b/exercises/practice/hamming/Hamming.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hamming/HammingTest.php b/exercises/practice/hamming/HammingTest.php
index bd21a30a..cbcf2a5e 100644
--- a/exercises/practice/hamming/HammingTest.php
+++ b/exercises/practice/hamming/HammingTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hello-world/.meta/example.php b/exercises/practice/hello-world/.meta/example.php
index e5b2b807..b9bc6d83 100644
--- a/exercises/practice/hello-world/.meta/example.php
+++ b/exercises/practice/hello-world/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hello-world/HelloWorld.php b/exercises/practice/hello-world/HelloWorld.php
index 34754a78..d5f0beda 100644
--- a/exercises/practice/hello-world/HelloWorld.php
+++ b/exercises/practice/hello-world/HelloWorld.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/hello-world/HelloWorldTest.php b/exercises/practice/hello-world/HelloWorldTest.php
index 22d82c71..78150831 100644
--- a/exercises/practice/hello-world/HelloWorldTest.php
+++ b/exercises/practice/hello-world/HelloWorldTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/isogram/.meta/example.php b/exercises/practice/isogram/.meta/example.php
index 2cb88755..0af81499 100644
--- a/exercises/practice/isogram/.meta/example.php
+++ b/exercises/practice/isogram/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/isogram/Isogram.php b/exercises/practice/isogram/Isogram.php
index 9fcd10c6..90f84200 100644
--- a/exercises/practice/isogram/Isogram.php
+++ b/exercises/practice/isogram/Isogram.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/isogram/IsogramTest.php b/exercises/practice/isogram/IsogramTest.php
index 6195554b..32422a21 100644
--- a/exercises/practice/isogram/IsogramTest.php
+++ b/exercises/practice/isogram/IsogramTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/largest-series-product/.meta/example.php b/exercises/practice/largest-series-product/.meta/example.php
index ec29f6a9..b98e6869 100644
--- a/exercises/practice/largest-series-product/.meta/example.php
+++ b/exercises/practice/largest-series-product/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/largest-series-product/LargestSeriesProduct.php b/exercises/practice/largest-series-product/LargestSeriesProduct.php
index 7491ec6c..9653e722 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProduct.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProduct.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/largest-series-product/LargestSeriesProductTest.php b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
index 50b27c76..f5acb3d3 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProductTest.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/leap/.meta/example.php b/exercises/practice/leap/.meta/example.php
index ce666fa9..59b83d52 100644
--- a/exercises/practice/leap/.meta/example.php
+++ b/exercises/practice/leap/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/leap/Leap.php b/exercises/practice/leap/Leap.php
index f8ace236..54946e90 100644
--- a/exercises/practice/leap/Leap.php
+++ b/exercises/practice/leap/Leap.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/leap/LeapTest.php b/exercises/practice/leap/LeapTest.php
index 885dcda1..1d16a84d 100644
--- a/exercises/practice/leap/LeapTest.php
+++ b/exercises/practice/leap/LeapTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/luhn/.meta/example.php b/exercises/practice/luhn/.meta/example.php
index 9cd040ba..25fc5a8f 100644
--- a/exercises/practice/luhn/.meta/example.php
+++ b/exercises/practice/luhn/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/luhn/Luhn.php b/exercises/practice/luhn/Luhn.php
index 03fdc566..ca0ab7ed 100644
--- a/exercises/practice/luhn/Luhn.php
+++ b/exercises/practice/luhn/Luhn.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/luhn/LuhnTest.php b/exercises/practice/luhn/LuhnTest.php
index 3a797200..cdc2f5c2 100644
--- a/exercises/practice/luhn/LuhnTest.php
+++ b/exercises/practice/luhn/LuhnTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/markdown/.meta/example.php b/exercises/practice/markdown/.meta/example.php
index 7d7b798a..e50865f0 100644
--- a/exercises/practice/markdown/.meta/example.php
+++ b/exercises/practice/markdown/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/markdown/Markdown.php b/exercises/practice/markdown/Markdown.php
index a5eb18da..d3959fcc 100644
--- a/exercises/practice/markdown/Markdown.php
+++ b/exercises/practice/markdown/Markdown.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/markdown/MarkdownTest.php b/exercises/practice/markdown/MarkdownTest.php
index 5334f08d..f0c7111e 100644
--- a/exercises/practice/markdown/MarkdownTest.php
+++ b/exercises/practice/markdown/MarkdownTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/mask-credit-card/.meta/example.php b/exercises/practice/mask-credit-card/.meta/example.php
index 0f2b467f..3bdce85d 100644
--- a/exercises/practice/mask-credit-card/.meta/example.php
+++ b/exercises/practice/mask-credit-card/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/mask-credit-card/MaskCreditCard.php b/exercises/practice/mask-credit-card/MaskCreditCard.php
index dbef46b9..237767b1 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCard.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCard.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/mask-credit-card/MaskCreditCardTest.php b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
index dd45c5a0..f6b6796d 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCardTest.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/matching-brackets/.meta/example.php b/exercises/practice/matching-brackets/.meta/example.php
index 18cf85f0..d56111b5 100644
--- a/exercises/practice/matching-brackets/.meta/example.php
+++ b/exercises/practice/matching-brackets/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/matching-brackets/MatchingBrackets.php b/exercises/practice/matching-brackets/MatchingBrackets.php
index 6d4948e4..9541f581 100644
--- a/exercises/practice/matching-brackets/MatchingBrackets.php
+++ b/exercises/practice/matching-brackets/MatchingBrackets.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/matching-brackets/MatchingBracketsTest.php b/exercises/practice/matching-brackets/MatchingBracketsTest.php
index 5e713a55..49bd6214 100644
--- a/exercises/practice/matching-brackets/MatchingBracketsTest.php
+++ b/exercises/practice/matching-brackets/MatchingBracketsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/meetup/.meta/example.php b/exercises/practice/meetup/.meta/example.php
index c546f7e1..fa8c606b 100644
--- a/exercises/practice/meetup/.meta/example.php
+++ b/exercises/practice/meetup/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/meetup/Meetup.php b/exercises/practice/meetup/Meetup.php
index cd32ddbd..9bb10314 100644
--- a/exercises/practice/meetup/Meetup.php
+++ b/exercises/practice/meetup/Meetup.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/meetup/MeetupTest.php b/exercises/practice/meetup/MeetupTest.php
index 03c27ce1..12b10112 100644
--- a/exercises/practice/meetup/MeetupTest.php
+++ b/exercises/practice/meetup/MeetupTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/minesweeper/.meta/example.php b/exercises/practice/minesweeper/.meta/example.php
index 4cf1adc6..0e65340d 100644
--- a/exercises/practice/minesweeper/.meta/example.php
+++ b/exercises/practice/minesweeper/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/minesweeper/Minesweeper.php b/exercises/practice/minesweeper/Minesweeper.php
index 7d01154d..73ce2b62 100644
--- a/exercises/practice/minesweeper/Minesweeper.php
+++ b/exercises/practice/minesweeper/Minesweeper.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/minesweeper/MinesweeperTest.php b/exercises/practice/minesweeper/MinesweeperTest.php
index 0e000938..1b1e2b65 100644
--- a/exercises/practice/minesweeper/MinesweeperTest.php
+++ b/exercises/practice/minesweeper/MinesweeperTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nth-prime/.meta/example.php b/exercises/practice/nth-prime/.meta/example.php
index a852346b..d0e38d0d 100644
--- a/exercises/practice/nth-prime/.meta/example.php
+++ b/exercises/practice/nth-prime/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nth-prime/NthPrime.php b/exercises/practice/nth-prime/NthPrime.php
index b5440472..8a4e936c 100644
--- a/exercises/practice/nth-prime/NthPrime.php
+++ b/exercises/practice/nth-prime/NthPrime.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nth-prime/NthPrimeTest.php b/exercises/practice/nth-prime/NthPrimeTest.php
index 586ef52f..9bca8f2d 100644
--- a/exercises/practice/nth-prime/NthPrimeTest.php
+++ b/exercises/practice/nth-prime/NthPrimeTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nucleotide-count/.meta/example.php b/exercises/practice/nucleotide-count/.meta/example.php
index b0dbbc1b..7a9cf5c4 100644
--- a/exercises/practice/nucleotide-count/.meta/example.php
+++ b/exercises/practice/nucleotide-count/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nucleotide-count/NucleotideCount.php b/exercises/practice/nucleotide-count/NucleotideCount.php
index e6e597ec..7378a3f3 100644
--- a/exercises/practice/nucleotide-count/NucleotideCount.php
+++ b/exercises/practice/nucleotide-count/NucleotideCount.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/nucleotide-count/NucleotideCountTest.php b/exercises/practice/nucleotide-count/NucleotideCountTest.php
index cd6bdbc4..a6412b79 100644
--- a/exercises/practice/nucleotide-count/NucleotideCountTest.php
+++ b/exercises/practice/nucleotide-count/NucleotideCountTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ocr-numbers/.meta/example.php b/exercises/practice/ocr-numbers/.meta/example.php
index 43163988..bfbd6118 100644
--- a/exercises/practice/ocr-numbers/.meta/example.php
+++ b/exercises/practice/ocr-numbers/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ocr-numbers/OcrNumbers.php b/exercises/practice/ocr-numbers/OcrNumbers.php
index bdf1bddb..ae46bc2e 100644
--- a/exercises/practice/ocr-numbers/OcrNumbers.php
+++ b/exercises/practice/ocr-numbers/OcrNumbers.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ocr-numbers/OcrNumbersTest.php b/exercises/practice/ocr-numbers/OcrNumbersTest.php
index cd9c137d..7014524e 100644
--- a/exercises/practice/ocr-numbers/OcrNumbersTest.php
+++ b/exercises/practice/ocr-numbers/OcrNumbersTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ordinal-number/.meta/example.php b/exercises/practice/ordinal-number/.meta/example.php
index b0cc8da7..75913b33 100644
--- a/exercises/practice/ordinal-number/.meta/example.php
+++ b/exercises/practice/ordinal-number/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ordinal-number/OrdinalNumber.php b/exercises/practice/ordinal-number/OrdinalNumber.php
index dcb8f057..7ba9134f 100644
--- a/exercises/practice/ordinal-number/OrdinalNumber.php
+++ b/exercises/practice/ordinal-number/OrdinalNumber.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/ordinal-number/OrdinalNumberTest.php b/exercises/practice/ordinal-number/OrdinalNumberTest.php
index 9214aa40..54e7275f 100644
--- a/exercises/practice/ordinal-number/OrdinalNumberTest.php
+++ b/exercises/practice/ordinal-number/OrdinalNumberTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/palindrome-products/.meta/example.php b/exercises/practice/palindrome-products/.meta/example.php
index bfdc77eb..a27a6ff4 100644
--- a/exercises/practice/palindrome-products/.meta/example.php
+++ b/exercises/practice/palindrome-products/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/palindrome-products/PalindromeProducts.php b/exercises/practice/palindrome-products/PalindromeProducts.php
index 7c677fa2..b4485a06 100644
--- a/exercises/practice/palindrome-products/PalindromeProducts.php
+++ b/exercises/practice/palindrome-products/PalindromeProducts.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/palindrome-products/PalindromeProductsTest.php b/exercises/practice/palindrome-products/PalindromeProductsTest.php
index d3771c03..ce4e464c 100644
--- a/exercises/practice/palindrome-products/PalindromeProductsTest.php
+++ b/exercises/practice/palindrome-products/PalindromeProductsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pangram/.meta/example.php b/exercises/practice/pangram/.meta/example.php
index dc4b23da..6c2e9879 100644
--- a/exercises/practice/pangram/.meta/example.php
+++ b/exercises/practice/pangram/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pangram/Pangram.php b/exercises/practice/pangram/Pangram.php
index 434e7769..812248ba 100644
--- a/exercises/practice/pangram/Pangram.php
+++ b/exercises/practice/pangram/Pangram.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pangram/PangramTest.php b/exercises/practice/pangram/PangramTest.php
index a5ba551c..366ad623 100644
--- a/exercises/practice/pangram/PangramTest.php
+++ b/exercises/practice/pangram/PangramTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pascals-triangle/.meta/example.php b/exercises/practice/pascals-triangle/.meta/example.php
index 6586d37a..27be7e1a 100644
--- a/exercises/practice/pascals-triangle/.meta/example.php
+++ b/exercises/practice/pascals-triangle/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pascals-triangle/PascalsTriangle.php b/exercises/practice/pascals-triangle/PascalsTriangle.php
index 0a67e4fb..4d675d69 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangle.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangle.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pascals-triangle/PascalsTriangleTest.php b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
index f1a4ab8b..790c218f 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangleTest.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/perfect-numbers/.meta/example.php b/exercises/practice/perfect-numbers/.meta/example.php
index aa043c15..a588445f 100644
--- a/exercises/practice/perfect-numbers/.meta/example.php
+++ b/exercises/practice/perfect-numbers/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/perfect-numbers/PerfectNumbers.php b/exercises/practice/perfect-numbers/PerfectNumbers.php
index 40bb47b7..c26a53b1 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbers.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbers.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/perfect-numbers/PerfectNumbersTest.php b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
index fc569bfc..b83b3c08 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbersTest.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/phone-number/.meta/example.php b/exercises/practice/phone-number/.meta/example.php
index eb3bd3a4..b91fc9a6 100644
--- a/exercises/practice/phone-number/.meta/example.php
+++ b/exercises/practice/phone-number/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/phone-number/PhoneNumber.php b/exercises/practice/phone-number/PhoneNumber.php
index 5b1f6493..df58a7fe 100644
--- a/exercises/practice/phone-number/PhoneNumber.php
+++ b/exercises/practice/phone-number/PhoneNumber.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/phone-number/PhoneNumberTest.php b/exercises/practice/phone-number/PhoneNumberTest.php
index e93fdeb5..f9abfc91 100644
--- a/exercises/practice/phone-number/PhoneNumberTest.php
+++ b/exercises/practice/phone-number/PhoneNumberTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pig-latin/.meta/example.php b/exercises/practice/pig-latin/.meta/example.php
index 94f24d75..73d5047e 100644
--- a/exercises/practice/pig-latin/.meta/example.php
+++ b/exercises/practice/pig-latin/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pig-latin/PigLatin.php b/exercises/practice/pig-latin/PigLatin.php
index c197fee2..4fc3eef2 100644
--- a/exercises/practice/pig-latin/PigLatin.php
+++ b/exercises/practice/pig-latin/PigLatin.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/pig-latin/PigLatinTest.php b/exercises/practice/pig-latin/PigLatinTest.php
index 35805a27..0b2ff82f 100644
--- a/exercises/practice/pig-latin/PigLatinTest.php
+++ b/exercises/practice/pig-latin/PigLatinTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/prime-factors/.meta/example.php b/exercises/practice/prime-factors/.meta/example.php
index d04fdce3..1771c5b7 100644
--- a/exercises/practice/prime-factors/.meta/example.php
+++ b/exercises/practice/prime-factors/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/prime-factors/PrimeFactors.php b/exercises/practice/prime-factors/PrimeFactors.php
index be39f715..ec760a27 100644
--- a/exercises/practice/prime-factors/PrimeFactors.php
+++ b/exercises/practice/prime-factors/PrimeFactors.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/prime-factors/PrimeFactorsTest.php b/exercises/practice/prime-factors/PrimeFactorsTest.php
index aae838e1..7f5164cc 100644
--- a/exercises/practice/prime-factors/PrimeFactorsTest.php
+++ b/exercises/practice/prime-factors/PrimeFactorsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/queen-attack/.meta/example.php b/exercises/practice/queen-attack/.meta/example.php
index ec56f2aa..4341bf61 100644
--- a/exercises/practice/queen-attack/.meta/example.php
+++ b/exercises/practice/queen-attack/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/queen-attack/QueenAttack.php b/exercises/practice/queen-attack/QueenAttack.php
index 1520a8d4..8be77363 100644
--- a/exercises/practice/queen-attack/QueenAttack.php
+++ b/exercises/practice/queen-attack/QueenAttack.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/queen-attack/QueenAttackTest.php b/exercises/practice/queen-attack/QueenAttackTest.php
index 8b177917..6ae085ba 100644
--- a/exercises/practice/queen-attack/QueenAttackTest.php
+++ b/exercises/practice/queen-attack/QueenAttackTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rail-fence-cipher/.meta/example.php b/exercises/practice/rail-fence-cipher/.meta/example.php
index ef378d66..d9ee6023 100644
--- a/exercises/practice/rail-fence-cipher/.meta/example.php
+++ b/exercises/practice/rail-fence-cipher/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipher.php b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
index 74f9879d..b9e74b92 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipher.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
index 7b4a4c3f..08eef014 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/raindrops/.meta/example.php b/exercises/practice/raindrops/.meta/example.php
index 534c6414..cad041ee 100644
--- a/exercises/practice/raindrops/.meta/example.php
+++ b/exercises/practice/raindrops/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/raindrops/Raindrops.php b/exercises/practice/raindrops/Raindrops.php
index d1f7c00a..8d52fc28 100644
--- a/exercises/practice/raindrops/Raindrops.php
+++ b/exercises/practice/raindrops/Raindrops.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/raindrops/RaindropsTest.php b/exercises/practice/raindrops/RaindropsTest.php
index 1bfbb1c2..0d3591c6 100644
--- a/exercises/practice/raindrops/RaindropsTest.php
+++ b/exercises/practice/raindrops/RaindropsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rna-transcription/.meta/example.php b/exercises/practice/rna-transcription/.meta/example.php
index 69981b21..4dc49afa 100644
--- a/exercises/practice/rna-transcription/.meta/example.php
+++ b/exercises/practice/rna-transcription/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rna-transcription/RnaTranscription.php b/exercises/practice/rna-transcription/RnaTranscription.php
index ea11ce77..b2aff733 100644
--- a/exercises/practice/rna-transcription/RnaTranscription.php
+++ b/exercises/practice/rna-transcription/RnaTranscription.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/rna-transcription/RnaTranscriptionTest.php b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
index e58ad49a..164037d9 100644
--- a/exercises/practice/rna-transcription/RnaTranscriptionTest.php
+++ b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-name/.meta/example.php b/exercises/practice/robot-name/.meta/example.php
index 38ffc4ca..ff14c497 100644
--- a/exercises/practice/robot-name/.meta/example.php
+++ b/exercises/practice/robot-name/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-name/RobotName.php b/exercises/practice/robot-name/RobotName.php
index 72cce3e7..f1b2a0a1 100644
--- a/exercises/practice/robot-name/RobotName.php
+++ b/exercises/practice/robot-name/RobotName.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-name/RobotNameTest.php b/exercises/practice/robot-name/RobotNameTest.php
index 5b938dbf..d740e00b 100644
--- a/exercises/practice/robot-name/RobotNameTest.php
+++ b/exercises/practice/robot-name/RobotNameTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-simulator/.meta/example.php b/exercises/practice/robot-simulator/.meta/example.php
index f0409b19..b4e50bc9 100644
--- a/exercises/practice/robot-simulator/.meta/example.php
+++ b/exercises/practice/robot-simulator/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-simulator/RobotSimulator.php b/exercises/practice/robot-simulator/RobotSimulator.php
index e0f4a0fb..f1538e05 100644
--- a/exercises/practice/robot-simulator/RobotSimulator.php
+++ b/exercises/practice/robot-simulator/RobotSimulator.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/robot-simulator/RobotSimulatorTest.php b/exercises/practice/robot-simulator/RobotSimulatorTest.php
index 79a43426..d58e866c 100644
--- a/exercises/practice/robot-simulator/RobotSimulatorTest.php
+++ b/exercises/practice/robot-simulator/RobotSimulatorTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/roman-numerals/.meta/example.php b/exercises/practice/roman-numerals/.meta/example.php
index 50272032..f33ba8f9 100644
--- a/exercises/practice/roman-numerals/.meta/example.php
+++ b/exercises/practice/roman-numerals/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/roman-numerals/RomanNumerals.php b/exercises/practice/roman-numerals/RomanNumerals.php
index 988076e3..569aa078 100644
--- a/exercises/practice/roman-numerals/RomanNumerals.php
+++ b/exercises/practice/roman-numerals/RomanNumerals.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/roman-numerals/RomanNumeralsTest.php b/exercises/practice/roman-numerals/RomanNumeralsTest.php
index 65a9e9e4..f5b042e5 100644
--- a/exercises/practice/roman-numerals/RomanNumeralsTest.php
+++ b/exercises/practice/roman-numerals/RomanNumeralsTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/run-length-encoding/.meta/example.php b/exercises/practice/run-length-encoding/.meta/example.php
index 13f8818e..9e8c5295 100644
--- a/exercises/practice/run-length-encoding/.meta/example.php
+++ b/exercises/practice/run-length-encoding/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/run-length-encoding/RunLengthEncoding.php b/exercises/practice/run-length-encoding/RunLengthEncoding.php
index f5da4539..72a5ab68 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncoding.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncoding.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
index 00e6de01..0a08db31 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/scrabble-score/.meta/example.php b/exercises/practice/scrabble-score/.meta/example.php
index d90292b8..5e96f540 100644
--- a/exercises/practice/scrabble-score/.meta/example.php
+++ b/exercises/practice/scrabble-score/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/scrabble-score/ScrabbleScore.php b/exercises/practice/scrabble-score/ScrabbleScore.php
index c51b12a2..deeb9cc0 100644
--- a/exercises/practice/scrabble-score/ScrabbleScore.php
+++ b/exercises/practice/scrabble-score/ScrabbleScore.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/scrabble-score/ScrabbleScoreTest.php b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
index cdacea69..e5edcdd0 100644
--- a/exercises/practice/scrabble-score/ScrabbleScoreTest.php
+++ b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/series/.meta/example.php b/exercises/practice/series/.meta/example.php
index 0d4b5467..0ed5804d 100644
--- a/exercises/practice/series/.meta/example.php
+++ b/exercises/practice/series/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/series/Series.php b/exercises/practice/series/Series.php
index 240c3a4b..70c5968f 100644
--- a/exercises/practice/series/Series.php
+++ b/exercises/practice/series/Series.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/series/SeriesTest.php b/exercises/practice/series/SeriesTest.php
index 8483a85a..4e196e5c 100644
--- a/exercises/practice/series/SeriesTest.php
+++ b/exercises/practice/series/SeriesTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sieve/.meta/example.php b/exercises/practice/sieve/.meta/example.php
index fe14aa3f..bd013081 100644
--- a/exercises/practice/sieve/.meta/example.php
+++ b/exercises/practice/sieve/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sieve/Sieve.php b/exercises/practice/sieve/Sieve.php
index 017eecde..7cb5a50d 100644
--- a/exercises/practice/sieve/Sieve.php
+++ b/exercises/practice/sieve/Sieve.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sieve/SieveTest.php b/exercises/practice/sieve/SieveTest.php
index 72f577a0..6d387565 100644
--- a/exercises/practice/sieve/SieveTest.php
+++ b/exercises/practice/sieve/SieveTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/space-age/.meta/example.php b/exercises/practice/space-age/.meta/example.php
index 7731a24c..dc727392 100644
--- a/exercises/practice/space-age/.meta/example.php
+++ b/exercises/practice/space-age/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/space-age/SpaceAge.php b/exercises/practice/space-age/SpaceAge.php
index 544ee342..95913d42 100644
--- a/exercises/practice/space-age/SpaceAge.php
+++ b/exercises/practice/space-age/SpaceAge.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/space-age/SpaceAgeTest.php b/exercises/practice/space-age/SpaceAgeTest.php
index 18d91cbd..2412ad78 100644
--- a/exercises/practice/space-age/SpaceAgeTest.php
+++ b/exercises/practice/space-age/SpaceAgeTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sum-of-multiples/.meta/example.php b/exercises/practice/sum-of-multiples/.meta/example.php
index 1f42073d..9533f23d 100644
--- a/exercises/practice/sum-of-multiples/.meta/example.php
+++ b/exercises/practice/sum-of-multiples/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiples.php b/exercises/practice/sum-of-multiples/SumOfMultiples.php
index cb2df0d2..0a34e3f1 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiples.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiples.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
index 64f56bcd..0699b343 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/transpose/.meta/example.php b/exercises/practice/transpose/.meta/example.php
index 35133f64..771c3a9c 100644
--- a/exercises/practice/transpose/.meta/example.php
+++ b/exercises/practice/transpose/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/transpose/Transpose.php b/exercises/practice/transpose/Transpose.php
index aa324d0e..257ebd33 100644
--- a/exercises/practice/transpose/Transpose.php
+++ b/exercises/practice/transpose/Transpose.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/transpose/TransposeTest.php b/exercises/practice/transpose/TransposeTest.php
index 079050ad..e64f13bd 100644
--- a/exercises/practice/transpose/TransposeTest.php
+++ b/exercises/practice/transpose/TransposeTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/triangle/.meta/example.php b/exercises/practice/triangle/.meta/example.php
index 7249cfd3..70ef41ca 100644
--- a/exercises/practice/triangle/.meta/example.php
+++ b/exercises/practice/triangle/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/triangle/Triangle.php b/exercises/practice/triangle/Triangle.php
index acf60b4f..28ff1e53 100644
--- a/exercises/practice/triangle/Triangle.php
+++ b/exercises/practice/triangle/Triangle.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/triangle/TriangleTest.php b/exercises/practice/triangle/TriangleTest.php
index 298e1129..0523f3c9 100644
--- a/exercises/practice/triangle/TriangleTest.php
+++ b/exercises/practice/triangle/TriangleTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/trinary/.meta/example.php b/exercises/practice/trinary/.meta/example.php
index 47075281..4b7f2986 100644
--- a/exercises/practice/trinary/.meta/example.php
+++ b/exercises/practice/trinary/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/trinary/Trinary.php b/exercises/practice/trinary/Trinary.php
index 0b37e714..d454597a 100644
--- a/exercises/practice/trinary/Trinary.php
+++ b/exercises/practice/trinary/Trinary.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/trinary/TrinaryTest.php b/exercises/practice/trinary/TrinaryTest.php
index 14b69401..598dc2f4 100644
--- a/exercises/practice/trinary/TrinaryTest.php
+++ b/exercises/practice/trinary/TrinaryTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/two-fer/.meta/example.php b/exercises/practice/two-fer/.meta/example.php
index 90042bdd..197bb96c 100644
--- a/exercises/practice/two-fer/.meta/example.php
+++ b/exercises/practice/two-fer/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/two-fer/TwoFer.php b/exercises/practice/two-fer/TwoFer.php
index c8f2c05e..8d014552 100644
--- a/exercises/practice/two-fer/TwoFer.php
+++ b/exercises/practice/two-fer/TwoFer.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/two-fer/TwoFerTest.php b/exercises/practice/two-fer/TwoFerTest.php
index 6305f849..fcbd3a66 100644
--- a/exercises/practice/two-fer/TwoFerTest.php
+++ b/exercises/practice/two-fer/TwoFerTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/variable-length-quantity/.meta/example.php b/exercises/practice/variable-length-quantity/.meta/example.php
index dafa1dae..409bf97b 100644
--- a/exercises/practice/variable-length-quantity/.meta/example.php
+++ b/exercises/practice/variable-length-quantity/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
index 456d73a1..22863d03 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
index 4649ba8a..017d2bc6 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/word-count/.meta/example.php b/exercises/practice/word-count/.meta/example.php
index b7f5a908..7e9b6bd3 100644
--- a/exercises/practice/word-count/.meta/example.php
+++ b/exercises/practice/word-count/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/word-count/WordCount.php b/exercises/practice/word-count/WordCount.php
index fc1a083e..c674b029 100644
--- a/exercises/practice/word-count/WordCount.php
+++ b/exercises/practice/word-count/WordCount.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/word-count/WordCountTest.php b/exercises/practice/word-count/WordCountTest.php
index c8935b65..e0250c14 100644
--- a/exercises/practice/word-count/WordCountTest.php
+++ b/exercises/practice/word-count/WordCountTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/wordy/.meta/example.php b/exercises/practice/wordy/.meta/example.php
index a7c143bf..e3d21291 100644
--- a/exercises/practice/wordy/.meta/example.php
+++ b/exercises/practice/wordy/.meta/example.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/wordy/Wordy.php b/exercises/practice/wordy/Wordy.php
index f4edd1d9..039b7244 100644
--- a/exercises/practice/wordy/Wordy.php
+++ b/exercises/practice/wordy/Wordy.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/exercises/practice/wordy/WordyTest.php b/exercises/practice/wordy/WordyTest.php
index f1b4b3ba..42414fbc 100644
--- a/exercises/practice/wordy/WordyTest.php
+++ b/exercises/practice/wordy/WordyTest.php
@@ -3,13 +3,14 @@
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
diff --git a/src/Sniffs/ExplainStrictTypesSniff.php b/src/Sniffs/ExplainStrictTypesSniff.php
index 178acf14..1fbd87a4 100644
--- a/src/Sniffs/ExplainStrictTypesSniff.php
+++ b/src/Sniffs/ExplainStrictTypesSniff.php
@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Exercism\Php\Sniffs;
+namespace Exercism\Sniffs;
 
 use PHP_CodeSniffer\Files\File;
 use PHP_CodeSniffer\Fixer;
@@ -14,13 +14,14 @@ class ExplainStrictTypesSniff implements Sniff
 /*
  * By adding type hints and enabling strict type checking, code can become easier to read,
  * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict,
- * which means they will attempt to change the original type to match the type specified by the type-declaration.
+ * By default, type declarations are non-strict, which means they will attempt to
+ * change the original type to match the type specified by the type-declaration.
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
  * To enable strict mode, a single declare directive must be placed at the top of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's return type.
+ * This directive not only affects the type declarations of parameters, but also a function's
+ * return type.
  *
  * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.

From 7d0873a92c5ff556b22dc2d7dc6f6a394899e136 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Holger=20Lo=CC=88sken?= <hl@inquence.com>
Date: Tue, 29 Jun 2021 17:45:30 +0200
Subject: [PATCH 8/8] Format strict type hint

---
 .../practice/accumulate/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/accumulate/Accumulate.php  | 22 ++++++++++++-------
 .../practice/accumulate/AccumulateTest.php    | 22 ++++++++++++-------
 exercises/practice/acronym/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/acronym/Acronym.php        | 22 ++++++++++++-------
 exercises/practice/acronym/AcronymTest.php    | 22 ++++++++++++-------
 .../practice/affine-cipher/.meta/example.php  | 22 ++++++++++++-------
 .../practice/affine-cipher/AffineCipher.php   | 22 ++++++++++++-------
 .../affine-cipher/AffineCipherTest.php        | 22 ++++++++++++-------
 .../practice/all-your-base/.meta/example.php  | 22 ++++++++++++-------
 .../practice/all-your-base/AllYourBase.php    | 22 ++++++++++++-------
 .../all-your-base/AllYourBaseTest.php         | 22 ++++++++++++-------
 .../practice/allergies/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/allergies/Allergies.php    | 22 ++++++++++++-------
 .../practice/allergies/AllergiesTest.php      | 22 ++++++++++++-------
 exercises/practice/anagram/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/anagram/Anagram.php        | 22 ++++++++++++-------
 exercises/practice/anagram/AnagramTest.php    | 22 ++++++++++++-------
 .../armstrong-numbers/.meta/example.php       | 22 ++++++++++++-------
 .../armstrong-numbers/ArmstrongNumbers.php    | 22 ++++++++++++-------
 .../ArmstrongNumbersTest.php                  | 22 ++++++++++++-------
 .../practice/atbash-cipher/.meta/example.php  | 22 ++++++++++++-------
 .../practice/atbash-cipher/AtbashCipher.php   | 22 ++++++++++++-------
 .../atbash-cipher/AtbashCipherTest.php        | 22 ++++++++++++-------
 .../practice/beer-song/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/beer-song/BeerSong.php     | 22 ++++++++++++-------
 exercises/practice/beer-song/BeerSongTest.php | 22 ++++++++++++-------
 .../practice/binary-search/.meta/example.php  | 22 ++++++++++++-------
 .../practice/binary-search/BinarySearch.php   | 22 ++++++++++++-------
 .../binary-search/BinarySearchTest.php        | 22 ++++++++++++-------
 exercises/practice/binary/.meta/example.php   | 22 ++++++++++++-------
 exercises/practice/binary/Binary.php          | 22 ++++++++++++-------
 exercises/practice/binary/BinaryTest.php      | 22 ++++++++++++-------
 exercises/practice/bob/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/bob/Bob.php                | 22 ++++++++++++-------
 exercises/practice/bob/BobTest.php            | 22 ++++++++++++-------
 .../practice/book-store/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/book-store/BookStore.php   | 22 ++++++++++++-------
 .../practice/book-store/BookStoreTest.php     | 22 ++++++++++++-------
 exercises/practice/bowling/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/bowling/Bowling.php        | 22 ++++++++++++-------
 exercises/practice/bowling/BowlingTest.php    | 22 ++++++++++++-------
 exercises/practice/change/.meta/example.php   | 22 ++++++++++++-------
 exercises/practice/change/Change.php          | 22 ++++++++++++-------
 exercises/practice/change/ChangeTest.php      | 22 ++++++++++++-------
 exercises/practice/clock/.meta/example.php    | 22 ++++++++++++-------
 exercises/practice/clock/Clock.php            | 22 ++++++++++++-------
 exercises/practice/clock/ClockTest.php        | 22 ++++++++++++-------
 .../collatz-conjecture/.meta/example.php      | 22 ++++++++++++-------
 .../collatz-conjecture/CollatzConjecture.php  | 22 ++++++++++++-------
 .../CollatzConjectureTest.php                 | 22 ++++++++++++-------
 exercises/practice/connect/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/connect/Connect.php        | 22 ++++++++++++-------
 exercises/practice/connect/ConnectTest.php    | 22 ++++++++++++-------
 .../practice/crypto-square/.meta/example.php  | 22 ++++++++++++-------
 .../practice/crypto-square/CryptoSquare.php   | 22 ++++++++++++-------
 .../crypto-square/CryptoSquareTest.php        | 22 ++++++++++++-------
 exercises/practice/diamond/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/diamond/Diamond.php        | 22 ++++++++++++-------
 exercises/practice/diamond/DiamondTest.php    | 22 ++++++++++++-------
 .../difference-of-squares/.meta/example.php   | 22 ++++++++++++-------
 .../DifferenceOfSquares.php                   | 22 ++++++++++++-------
 .../DifferenceOfSquaresTest.php               | 22 ++++++++++++-------
 exercises/practice/etl/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/etl/Etl.php                | 22 ++++++++++++-------
 exercises/practice/etl/EtlTest.php            | 22 ++++++++++++-------
 .../practice/flatten-array/.meta/example.php  | 22 ++++++++++++-------
 .../practice/flatten-array/FlattenArray.php   | 22 ++++++++++++-------
 .../flatten-array/FlattenArrayTest.php        | 22 ++++++++++++-------
 .../practice/gigasecond/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/gigasecond/Gigasecond.php  | 22 ++++++++++++-------
 .../practice/gigasecond/GigasecondTest.php    | 22 ++++++++++++-------
 .../practice/grade-school/.meta/example.php   | 22 ++++++++++++-------
 .../practice/grade-school/GradeSchool.php     | 22 ++++++++++++-------
 .../practice/grade-school/GradeSchoolTest.php | 22 ++++++++++++-------
 exercises/practice/grains/.meta/example.php   | 22 ++++++++++++-------
 exercises/practice/grains/Grains.php          | 22 ++++++++++++-------
 exercises/practice/grains/GrainsTest.php      | 22 ++++++++++++-------
 exercises/practice/hamming/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/hamming/Hamming.php        | 22 ++++++++++++-------
 exercises/practice/hamming/HammingTest.php    | 22 ++++++++++++-------
 .../practice/hello-world/.meta/example.php    | 22 ++++++++++++-------
 exercises/practice/hello-world/HelloWorld.php | 22 ++++++++++++-------
 .../practice/hello-world/HelloWorldTest.php   | 22 ++++++++++++-------
 exercises/practice/isogram/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/isogram/Isogram.php        | 22 ++++++++++++-------
 exercises/practice/isogram/IsogramTest.php    | 22 ++++++++++++-------
 .../largest-series-product/.meta/example.php  | 22 ++++++++++++-------
 .../LargestSeriesProduct.php                  | 22 ++++++++++++-------
 .../LargestSeriesProductTest.php              | 22 ++++++++++++-------
 exercises/practice/leap/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/leap/Leap.php              | 22 ++++++++++++-------
 exercises/practice/leap/LeapTest.php          | 22 ++++++++++++-------
 exercises/practice/luhn/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/luhn/Luhn.php              | 22 ++++++++++++-------
 exercises/practice/luhn/LuhnTest.php          | 22 ++++++++++++-------
 exercises/practice/markdown/.meta/example.php | 22 ++++++++++++-------
 exercises/practice/markdown/Markdown.php      | 22 ++++++++++++-------
 exercises/practice/markdown/MarkdownTest.php  | 22 ++++++++++++-------
 .../mask-credit-card/.meta/example.php        | 22 ++++++++++++-------
 .../mask-credit-card/MaskCreditCard.php       | 22 ++++++++++++-------
 .../mask-credit-card/MaskCreditCardTest.php   | 22 ++++++++++++-------
 .../matching-brackets/.meta/example.php       | 22 ++++++++++++-------
 .../matching-brackets/MatchingBrackets.php    | 22 ++++++++++++-------
 .../MatchingBracketsTest.php                  | 22 ++++++++++++-------
 exercises/practice/meetup/.meta/example.php   | 22 ++++++++++++-------
 exercises/practice/meetup/Meetup.php          | 22 ++++++++++++-------
 exercises/practice/meetup/MeetupTest.php      | 22 ++++++++++++-------
 .../practice/minesweeper/.meta/example.php    | 22 ++++++++++++-------
 .../practice/minesweeper/Minesweeper.php      | 22 ++++++++++++-------
 .../practice/minesweeper/MinesweeperTest.php  | 22 ++++++++++++-------
 .../practice/nth-prime/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/nth-prime/NthPrime.php     | 22 ++++++++++++-------
 exercises/practice/nth-prime/NthPrimeTest.php | 22 ++++++++++++-------
 .../nucleotide-count/.meta/example.php        | 22 ++++++++++++-------
 .../nucleotide-count/NucleotideCount.php      | 22 ++++++++++++-------
 .../nucleotide-count/NucleotideCountTest.php  | 22 ++++++++++++-------
 .../practice/ocr-numbers/.meta/example.php    | 22 ++++++++++++-------
 exercises/practice/ocr-numbers/OcrNumbers.php | 22 ++++++++++++-------
 .../practice/ocr-numbers/OcrNumbersTest.php   | 22 ++++++++++++-------
 .../practice/ordinal-number/.meta/example.php | 22 ++++++++++++-------
 .../practice/ordinal-number/OrdinalNumber.php | 22 ++++++++++++-------
 .../ordinal-number/OrdinalNumberTest.php      | 22 ++++++++++++-------
 .../palindrome-products/.meta/example.php     | 22 ++++++++++++-------
 .../PalindromeProducts.php                    | 22 ++++++++++++-------
 .../PalindromeProductsTest.php                | 22 ++++++++++++-------
 exercises/practice/pangram/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/pangram/Pangram.php        | 22 ++++++++++++-------
 exercises/practice/pangram/PangramTest.php    | 22 ++++++++++++-------
 .../pascals-triangle/.meta/example.php        | 22 ++++++++++++-------
 .../pascals-triangle/PascalsTriangle.php      | 22 ++++++++++++-------
 .../pascals-triangle/PascalsTriangleTest.php  | 22 ++++++++++++-------
 .../perfect-numbers/.meta/example.php         | 22 ++++++++++++-------
 .../perfect-numbers/PerfectNumbers.php        | 22 ++++++++++++-------
 .../perfect-numbers/PerfectNumbersTest.php    | 22 ++++++++++++-------
 .../practice/phone-number/.meta/example.php   | 22 ++++++++++++-------
 .../practice/phone-number/PhoneNumber.php     | 22 ++++++++++++-------
 .../practice/phone-number/PhoneNumberTest.php | 22 ++++++++++++-------
 .../practice/pig-latin/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/pig-latin/PigLatin.php     | 22 ++++++++++++-------
 exercises/practice/pig-latin/PigLatinTest.php | 22 ++++++++++++-------
 .../practice/prime-factors/.meta/example.php  | 22 ++++++++++++-------
 .../practice/prime-factors/PrimeFactors.php   | 22 ++++++++++++-------
 .../prime-factors/PrimeFactorsTest.php        | 22 ++++++++++++-------
 .../practice/queen-attack/.meta/example.php   | 22 ++++++++++++-------
 .../practice/queen-attack/QueenAttack.php     | 22 ++++++++++++-------
 .../practice/queen-attack/QueenAttackTest.php | 22 ++++++++++++-------
 .../rail-fence-cipher/.meta/example.php       | 22 ++++++++++++-------
 .../rail-fence-cipher/RailFenceCipher.php     | 22 ++++++++++++-------
 .../rail-fence-cipher/RailFenceCipherTest.php | 22 ++++++++++++-------
 .../practice/raindrops/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/raindrops/Raindrops.php    | 22 ++++++++++++-------
 .../practice/raindrops/RaindropsTest.php      | 22 ++++++++++++-------
 .../rna-transcription/.meta/example.php       | 22 ++++++++++++-------
 .../rna-transcription/RnaTranscription.php    | 22 ++++++++++++-------
 .../RnaTranscriptionTest.php                  | 22 ++++++++++++-------
 .../practice/robot-name/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/robot-name/RobotName.php   | 22 ++++++++++++-------
 .../practice/robot-name/RobotNameTest.php     | 22 ++++++++++++-------
 .../robot-simulator/.meta/example.php         | 22 ++++++++++++-------
 .../robot-simulator/RobotSimulator.php        | 22 ++++++++++++-------
 .../robot-simulator/RobotSimulatorTest.php    | 22 ++++++++++++-------
 .../practice/roman-numerals/.meta/example.php | 22 ++++++++++++-------
 .../practice/roman-numerals/RomanNumerals.php | 22 ++++++++++++-------
 .../roman-numerals/RomanNumeralsTest.php      | 22 ++++++++++++-------
 .../run-length-encoding/.meta/example.php     | 22 ++++++++++++-------
 .../run-length-encoding/RunLengthEncoding.php | 22 ++++++++++++-------
 .../RunLengthEncodingTest.php                 | 22 ++++++++++++-------
 .../practice/scrabble-score/.meta/example.php | 22 ++++++++++++-------
 .../practice/scrabble-score/ScrabbleScore.php | 22 ++++++++++++-------
 .../scrabble-score/ScrabbleScoreTest.php      | 22 ++++++++++++-------
 exercises/practice/series/.meta/example.php   | 22 ++++++++++++-------
 exercises/practice/series/Series.php          | 22 ++++++++++++-------
 exercises/practice/series/SeriesTest.php      | 22 ++++++++++++-------
 exercises/practice/sieve/.meta/example.php    | 22 ++++++++++++-------
 exercises/practice/sieve/Sieve.php            | 22 ++++++++++++-------
 exercises/practice/sieve/SieveTest.php        | 22 ++++++++++++-------
 .../practice/space-age/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/space-age/SpaceAge.php     | 22 ++++++++++++-------
 exercises/practice/space-age/SpaceAgeTest.php | 22 ++++++++++++-------
 .../sum-of-multiples/.meta/example.php        | 22 ++++++++++++-------
 .../sum-of-multiples/SumOfMultiples.php       | 22 ++++++++++++-------
 .../sum-of-multiples/SumOfMultiplesTest.php   | 22 ++++++++++++-------
 .../practice/transpose/.meta/example.php      | 22 ++++++++++++-------
 exercises/practice/transpose/Transpose.php    | 22 ++++++++++++-------
 .../practice/transpose/TransposeTest.php      | 22 ++++++++++++-------
 exercises/practice/triangle/.meta/example.php | 22 ++++++++++++-------
 exercises/practice/triangle/Triangle.php      | 22 ++++++++++++-------
 exercises/practice/triangle/TriangleTest.php  | 22 ++++++++++++-------
 exercises/practice/trinary/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/trinary/Trinary.php        | 22 ++++++++++++-------
 exercises/practice/trinary/TrinaryTest.php    | 22 ++++++++++++-------
 exercises/practice/two-fer/.meta/example.php  | 22 ++++++++++++-------
 exercises/practice/two-fer/TwoFer.php         | 22 ++++++++++++-------
 exercises/practice/two-fer/TwoFerTest.php     | 22 ++++++++++++-------
 .../.meta/example.php                         | 22 ++++++++++++-------
 .../VariableLengthQuantity.php                | 22 ++++++++++++-------
 .../VariableLengthQuantityTest.php            | 22 ++++++++++++-------
 .../practice/word-count/.meta/example.php     | 22 ++++++++++++-------
 exercises/practice/word-count/WordCount.php   | 22 ++++++++++++-------
 .../practice/word-count/WordCountTest.php     | 22 ++++++++++++-------
 exercises/practice/wordy/.meta/example.php    | 22 ++++++++++++-------
 exercises/practice/wordy/Wordy.php            | 22 ++++++++++++-------
 exercises/practice/wordy/WordyTest.php        | 22 ++++++++++++-------
 src/Sniffs/ExplainStrictTypesSniff.php        | 22 ++++++++++++-------
 205 files changed, 2870 insertions(+), 1640 deletions(-)

diff --git a/exercises/practice/accumulate/.meta/example.php b/exercises/practice/accumulate/.meta/example.php
index f2709268..b762cc54 100644
--- a/exercises/practice/accumulate/.meta/example.php
+++ b/exercises/practice/accumulate/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/accumulate/Accumulate.php b/exercises/practice/accumulate/Accumulate.php
index f2a44f54..a1dae7f6 100644
--- a/exercises/practice/accumulate/Accumulate.php
+++ b/exercises/practice/accumulate/Accumulate.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/accumulate/AccumulateTest.php b/exercises/practice/accumulate/AccumulateTest.php
index c666bf67..29ae9d9a 100644
--- a/exercises/practice/accumulate/AccumulateTest.php
+++ b/exercises/practice/accumulate/AccumulateTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/acronym/.meta/example.php b/exercises/practice/acronym/.meta/example.php
index 039ef4a3..f0da6efe 100644
--- a/exercises/practice/acronym/.meta/example.php
+++ b/exercises/practice/acronym/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/acronym/Acronym.php b/exercises/practice/acronym/Acronym.php
index 1f56606b..412460d4 100644
--- a/exercises/practice/acronym/Acronym.php
+++ b/exercises/practice/acronym/Acronym.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/acronym/AcronymTest.php b/exercises/practice/acronym/AcronymTest.php
index f3626334..99d1e3fb 100644
--- a/exercises/practice/acronym/AcronymTest.php
+++ b/exercises/practice/acronym/AcronymTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/affine-cipher/.meta/example.php b/exercises/practice/affine-cipher/.meta/example.php
index 1e1b4398..95a07ef1 100644
--- a/exercises/practice/affine-cipher/.meta/example.php
+++ b/exercises/practice/affine-cipher/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/affine-cipher/AffineCipher.php b/exercises/practice/affine-cipher/AffineCipher.php
index 056d57b5..08c7f65d 100644
--- a/exercises/practice/affine-cipher/AffineCipher.php
+++ b/exercises/practice/affine-cipher/AffineCipher.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/affine-cipher/AffineCipherTest.php b/exercises/practice/affine-cipher/AffineCipherTest.php
index 7eb88c75..15b494f5 100644
--- a/exercises/practice/affine-cipher/AffineCipherTest.php
+++ b/exercises/practice/affine-cipher/AffineCipherTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/all-your-base/.meta/example.php b/exercises/practice/all-your-base/.meta/example.php
index c1711e90..0a6616f5 100644
--- a/exercises/practice/all-your-base/.meta/example.php
+++ b/exercises/practice/all-your-base/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/all-your-base/AllYourBase.php b/exercises/practice/all-your-base/AllYourBase.php
index a3cf642f..18e33cc4 100644
--- a/exercises/practice/all-your-base/AllYourBase.php
+++ b/exercises/practice/all-your-base/AllYourBase.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/all-your-base/AllYourBaseTest.php b/exercises/practice/all-your-base/AllYourBaseTest.php
index d9891468..f24b0fc3 100644
--- a/exercises/practice/all-your-base/AllYourBaseTest.php
+++ b/exercises/practice/all-your-base/AllYourBaseTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/allergies/.meta/example.php b/exercises/practice/allergies/.meta/example.php
index e1cb39ce..d60bd762 100644
--- a/exercises/practice/allergies/.meta/example.php
+++ b/exercises/practice/allergies/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/allergies/Allergies.php b/exercises/practice/allergies/Allergies.php
index 24cd043a..3e35b88c 100644
--- a/exercises/practice/allergies/Allergies.php
+++ b/exercises/practice/allergies/Allergies.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/allergies/AllergiesTest.php b/exercises/practice/allergies/AllergiesTest.php
index 42fedf94..7c5ebad7 100644
--- a/exercises/practice/allergies/AllergiesTest.php
+++ b/exercises/practice/allergies/AllergiesTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/anagram/.meta/example.php b/exercises/practice/anagram/.meta/example.php
index 80245d58..30747f9e 100644
--- a/exercises/practice/anagram/.meta/example.php
+++ b/exercises/practice/anagram/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/anagram/Anagram.php b/exercises/practice/anagram/Anagram.php
index e7457aec..f8fcd6ae 100644
--- a/exercises/practice/anagram/Anagram.php
+++ b/exercises/practice/anagram/Anagram.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/anagram/AnagramTest.php b/exercises/practice/anagram/AnagramTest.php
index 5050fc0d..5fd75e82 100644
--- a/exercises/practice/anagram/AnagramTest.php
+++ b/exercises/practice/anagram/AnagramTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/armstrong-numbers/.meta/example.php b/exercises/practice/armstrong-numbers/.meta/example.php
index cfe68304..2d61033e 100644
--- a/exercises/practice/armstrong-numbers/.meta/example.php
+++ b/exercises/practice/armstrong-numbers/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
index 538b15e8..d1859145 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbers.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
index 92899485..9623f77a 100644
--- a/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
+++ b/exercises/practice/armstrong-numbers/ArmstrongNumbersTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/atbash-cipher/.meta/example.php b/exercises/practice/atbash-cipher/.meta/example.php
index 4ac371cb..9fdcf18b 100644
--- a/exercises/practice/atbash-cipher/.meta/example.php
+++ b/exercises/practice/atbash-cipher/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/atbash-cipher/AtbashCipher.php b/exercises/practice/atbash-cipher/AtbashCipher.php
index 0e50bdb2..90dfadd4 100644
--- a/exercises/practice/atbash-cipher/AtbashCipher.php
+++ b/exercises/practice/atbash-cipher/AtbashCipher.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/atbash-cipher/AtbashCipherTest.php b/exercises/practice/atbash-cipher/AtbashCipherTest.php
index 5d3a73ed..a7ec016b 100644
--- a/exercises/practice/atbash-cipher/AtbashCipherTest.php
+++ b/exercises/practice/atbash-cipher/AtbashCipherTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/beer-song/.meta/example.php b/exercises/practice/beer-song/.meta/example.php
index f8b8c5fd..6a4d2d89 100644
--- a/exercises/practice/beer-song/.meta/example.php
+++ b/exercises/practice/beer-song/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/beer-song/BeerSong.php b/exercises/practice/beer-song/BeerSong.php
index 5931ae2b..5ef7325c 100644
--- a/exercises/practice/beer-song/BeerSong.php
+++ b/exercises/practice/beer-song/BeerSong.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/beer-song/BeerSongTest.php b/exercises/practice/beer-song/BeerSongTest.php
index 463501c9..8f5d79df 100644
--- a/exercises/practice/beer-song/BeerSongTest.php
+++ b/exercises/practice/beer-song/BeerSongTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary-search/.meta/example.php b/exercises/practice/binary-search/.meta/example.php
index 832e45ad..a67c0ce7 100644
--- a/exercises/practice/binary-search/.meta/example.php
+++ b/exercises/practice/binary-search/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary-search/BinarySearch.php b/exercises/practice/binary-search/BinarySearch.php
index cda7c816..fdae118f 100644
--- a/exercises/practice/binary-search/BinarySearch.php
+++ b/exercises/practice/binary-search/BinarySearch.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary-search/BinarySearchTest.php b/exercises/practice/binary-search/BinarySearchTest.php
index 7d090f37..f7546253 100644
--- a/exercises/practice/binary-search/BinarySearchTest.php
+++ b/exercises/practice/binary-search/BinarySearchTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary/.meta/example.php b/exercises/practice/binary/.meta/example.php
index e541eff2..5ff19a31 100644
--- a/exercises/practice/binary/.meta/example.php
+++ b/exercises/practice/binary/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary/Binary.php b/exercises/practice/binary/Binary.php
index e236405f..81592d44 100644
--- a/exercises/practice/binary/Binary.php
+++ b/exercises/practice/binary/Binary.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/binary/BinaryTest.php b/exercises/practice/binary/BinaryTest.php
index 2f0719d2..a9ddf7dc 100644
--- a/exercises/practice/binary/BinaryTest.php
+++ b/exercises/practice/binary/BinaryTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bob/.meta/example.php b/exercises/practice/bob/.meta/example.php
index 09277a9b..fbc38e55 100644
--- a/exercises/practice/bob/.meta/example.php
+++ b/exercises/practice/bob/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bob/Bob.php b/exercises/practice/bob/Bob.php
index b7e0ae32..aa0abc6e 100644
--- a/exercises/practice/bob/Bob.php
+++ b/exercises/practice/bob/Bob.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bob/BobTest.php b/exercises/practice/bob/BobTest.php
index 72c9eeee..9828e46e 100644
--- a/exercises/practice/bob/BobTest.php
+++ b/exercises/practice/bob/BobTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/book-store/.meta/example.php b/exercises/practice/book-store/.meta/example.php
index 5aefe541..5e4f94a8 100644
--- a/exercises/practice/book-store/.meta/example.php
+++ b/exercises/practice/book-store/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/book-store/BookStore.php b/exercises/practice/book-store/BookStore.php
index c66744a6..4a4efd9d 100644
--- a/exercises/practice/book-store/BookStore.php
+++ b/exercises/practice/book-store/BookStore.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/book-store/BookStoreTest.php b/exercises/practice/book-store/BookStoreTest.php
index 42c53f00..b99588e8 100644
--- a/exercises/practice/book-store/BookStoreTest.php
+++ b/exercises/practice/book-store/BookStoreTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bowling/.meta/example.php b/exercises/practice/bowling/.meta/example.php
index 4dfd736c..5fc82f24 100644
--- a/exercises/practice/bowling/.meta/example.php
+++ b/exercises/practice/bowling/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bowling/Bowling.php b/exercises/practice/bowling/Bowling.php
index 15a8fe0b..6810f2c1 100644
--- a/exercises/practice/bowling/Bowling.php
+++ b/exercises/practice/bowling/Bowling.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/bowling/BowlingTest.php b/exercises/practice/bowling/BowlingTest.php
index 3d13d175..1072356a 100644
--- a/exercises/practice/bowling/BowlingTest.php
+++ b/exercises/practice/bowling/BowlingTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/change/.meta/example.php b/exercises/practice/change/.meta/example.php
index 251d9cb7..b8af1ce6 100644
--- a/exercises/practice/change/.meta/example.php
+++ b/exercises/practice/change/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/change/Change.php b/exercises/practice/change/Change.php
index f3c4f4d8..9629c401 100644
--- a/exercises/practice/change/Change.php
+++ b/exercises/practice/change/Change.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/change/ChangeTest.php b/exercises/practice/change/ChangeTest.php
index 7d417dfe..6746da6e 100644
--- a/exercises/practice/change/ChangeTest.php
+++ b/exercises/practice/change/ChangeTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/clock/.meta/example.php b/exercises/practice/clock/.meta/example.php
index f430a264..35cb4ee8 100644
--- a/exercises/practice/clock/.meta/example.php
+++ b/exercises/practice/clock/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/clock/Clock.php b/exercises/practice/clock/Clock.php
index 503daf42..5e5b669e 100644
--- a/exercises/practice/clock/Clock.php
+++ b/exercises/practice/clock/Clock.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/clock/ClockTest.php b/exercises/practice/clock/ClockTest.php
index 1e27be5c..b3af516f 100644
--- a/exercises/practice/clock/ClockTest.php
+++ b/exercises/practice/clock/ClockTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/collatz-conjecture/.meta/example.php b/exercises/practice/collatz-conjecture/.meta/example.php
index 9f8364cd..502da2d0 100644
--- a/exercises/practice/collatz-conjecture/.meta/example.php
+++ b/exercises/practice/collatz-conjecture/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/collatz-conjecture/CollatzConjecture.php b/exercises/practice/collatz-conjecture/CollatzConjecture.php
index f5f553ee..54112f8d 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjecture.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjecture.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
index b929e378..387fd65e 100644
--- a/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
+++ b/exercises/practice/collatz-conjecture/CollatzConjectureTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/connect/.meta/example.php b/exercises/practice/connect/.meta/example.php
index a01bf9f3..527dabb9 100644
--- a/exercises/practice/connect/.meta/example.php
+++ b/exercises/practice/connect/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/connect/Connect.php b/exercises/practice/connect/Connect.php
index b6a3f773..7acea120 100644
--- a/exercises/practice/connect/Connect.php
+++ b/exercises/practice/connect/Connect.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/connect/ConnectTest.php b/exercises/practice/connect/ConnectTest.php
index dfc7ff1e..862e9758 100644
--- a/exercises/practice/connect/ConnectTest.php
+++ b/exercises/practice/connect/ConnectTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/crypto-square/.meta/example.php b/exercises/practice/crypto-square/.meta/example.php
index a2ba582c..1fbb9da1 100644
--- a/exercises/practice/crypto-square/.meta/example.php
+++ b/exercises/practice/crypto-square/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/crypto-square/CryptoSquare.php b/exercises/practice/crypto-square/CryptoSquare.php
index b33bb9fa..f551508e 100644
--- a/exercises/practice/crypto-square/CryptoSquare.php
+++ b/exercises/practice/crypto-square/CryptoSquare.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/crypto-square/CryptoSquareTest.php b/exercises/practice/crypto-square/CryptoSquareTest.php
index 1c2ac23a..e21a3d33 100644
--- a/exercises/practice/crypto-square/CryptoSquareTest.php
+++ b/exercises/practice/crypto-square/CryptoSquareTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/diamond/.meta/example.php b/exercises/practice/diamond/.meta/example.php
index a0c075d1..8f4b7a8c 100644
--- a/exercises/practice/diamond/.meta/example.php
+++ b/exercises/practice/diamond/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/diamond/Diamond.php b/exercises/practice/diamond/Diamond.php
index ed4ce369..f76ea953 100644
--- a/exercises/practice/diamond/Diamond.php
+++ b/exercises/practice/diamond/Diamond.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/diamond/DiamondTest.php b/exercises/practice/diamond/DiamondTest.php
index 54e66c63..40c35b9a 100644
--- a/exercises/practice/diamond/DiamondTest.php
+++ b/exercises/practice/diamond/DiamondTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/difference-of-squares/.meta/example.php b/exercises/practice/difference-of-squares/.meta/example.php
index c4b2db15..f336ed5a 100644
--- a/exercises/practice/difference-of-squares/.meta/example.php
+++ b/exercises/practice/difference-of-squares/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquares.php b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
index ba5e8649..fabc2745 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquares.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquares.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
index acc329b1..06b80b83 100644
--- a/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
+++ b/exercises/practice/difference-of-squares/DifferenceOfSquaresTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/etl/.meta/example.php b/exercises/practice/etl/.meta/example.php
index 42386d0b..611723a4 100644
--- a/exercises/practice/etl/.meta/example.php
+++ b/exercises/practice/etl/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/etl/Etl.php b/exercises/practice/etl/Etl.php
index 83672ea3..069d208e 100644
--- a/exercises/practice/etl/Etl.php
+++ b/exercises/practice/etl/Etl.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/etl/EtlTest.php b/exercises/practice/etl/EtlTest.php
index fe686485..93aff504 100644
--- a/exercises/practice/etl/EtlTest.php
+++ b/exercises/practice/etl/EtlTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/flatten-array/.meta/example.php b/exercises/practice/flatten-array/.meta/example.php
index e524d978..8c20f140 100644
--- a/exercises/practice/flatten-array/.meta/example.php
+++ b/exercises/practice/flatten-array/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/flatten-array/FlattenArray.php b/exercises/practice/flatten-array/FlattenArray.php
index 51d21da9..ea39046e 100644
--- a/exercises/practice/flatten-array/FlattenArray.php
+++ b/exercises/practice/flatten-array/FlattenArray.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/flatten-array/FlattenArrayTest.php b/exercises/practice/flatten-array/FlattenArrayTest.php
index f17d94f3..af1fdfc7 100644
--- a/exercises/practice/flatten-array/FlattenArrayTest.php
+++ b/exercises/practice/flatten-array/FlattenArrayTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/gigasecond/.meta/example.php b/exercises/practice/gigasecond/.meta/example.php
index a248ba33..8242932a 100644
--- a/exercises/practice/gigasecond/.meta/example.php
+++ b/exercises/practice/gigasecond/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/gigasecond/Gigasecond.php b/exercises/practice/gigasecond/Gigasecond.php
index 3aebebc2..70aec171 100644
--- a/exercises/practice/gigasecond/Gigasecond.php
+++ b/exercises/practice/gigasecond/Gigasecond.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/gigasecond/GigasecondTest.php b/exercises/practice/gigasecond/GigasecondTest.php
index bf940227..6f2bee16 100644
--- a/exercises/practice/gigasecond/GigasecondTest.php
+++ b/exercises/practice/gigasecond/GigasecondTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grade-school/.meta/example.php b/exercises/practice/grade-school/.meta/example.php
index 591cde41..dcda6e4a 100644
--- a/exercises/practice/grade-school/.meta/example.php
+++ b/exercises/practice/grade-school/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grade-school/GradeSchool.php b/exercises/practice/grade-school/GradeSchool.php
index 13aec8b8..f143fbfc 100644
--- a/exercises/practice/grade-school/GradeSchool.php
+++ b/exercises/practice/grade-school/GradeSchool.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grade-school/GradeSchoolTest.php b/exercises/practice/grade-school/GradeSchoolTest.php
index 16e90915..baea548b 100644
--- a/exercises/practice/grade-school/GradeSchoolTest.php
+++ b/exercises/practice/grade-school/GradeSchoolTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grains/.meta/example.php b/exercises/practice/grains/.meta/example.php
index 40a2fb41..72f006ba 100644
--- a/exercises/practice/grains/.meta/example.php
+++ b/exercises/practice/grains/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grains/Grains.php b/exercises/practice/grains/Grains.php
index 59b64fa8..909bb1f5 100644
--- a/exercises/practice/grains/Grains.php
+++ b/exercises/practice/grains/Grains.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/grains/GrainsTest.php b/exercises/practice/grains/GrainsTest.php
index a19cf68a..2f170a95 100644
--- a/exercises/practice/grains/GrainsTest.php
+++ b/exercises/practice/grains/GrainsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hamming/.meta/example.php b/exercises/practice/hamming/.meta/example.php
index 152ecb92..b6671e35 100644
--- a/exercises/practice/hamming/.meta/example.php
+++ b/exercises/practice/hamming/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hamming/Hamming.php b/exercises/practice/hamming/Hamming.php
index dfbccd52..9b7ef0ea 100644
--- a/exercises/practice/hamming/Hamming.php
+++ b/exercises/practice/hamming/Hamming.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hamming/HammingTest.php b/exercises/practice/hamming/HammingTest.php
index cbcf2a5e..88e2ab7a 100644
--- a/exercises/practice/hamming/HammingTest.php
+++ b/exercises/practice/hamming/HammingTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hello-world/.meta/example.php b/exercises/practice/hello-world/.meta/example.php
index b9bc6d83..519b5597 100644
--- a/exercises/practice/hello-world/.meta/example.php
+++ b/exercises/practice/hello-world/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hello-world/HelloWorld.php b/exercises/practice/hello-world/HelloWorld.php
index d5f0beda..f33ef709 100644
--- a/exercises/practice/hello-world/HelloWorld.php
+++ b/exercises/practice/hello-world/HelloWorld.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/hello-world/HelloWorldTest.php b/exercises/practice/hello-world/HelloWorldTest.php
index 78150831..d5dbdf37 100644
--- a/exercises/practice/hello-world/HelloWorldTest.php
+++ b/exercises/practice/hello-world/HelloWorldTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/isogram/.meta/example.php b/exercises/practice/isogram/.meta/example.php
index 0af81499..44149a7c 100644
--- a/exercises/practice/isogram/.meta/example.php
+++ b/exercises/practice/isogram/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/isogram/Isogram.php b/exercises/practice/isogram/Isogram.php
index 90f84200..437215b6 100644
--- a/exercises/practice/isogram/Isogram.php
+++ b/exercises/practice/isogram/Isogram.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/isogram/IsogramTest.php b/exercises/practice/isogram/IsogramTest.php
index 32422a21..af887307 100644
--- a/exercises/practice/isogram/IsogramTest.php
+++ b/exercises/practice/isogram/IsogramTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/largest-series-product/.meta/example.php b/exercises/practice/largest-series-product/.meta/example.php
index b98e6869..a747f11c 100644
--- a/exercises/practice/largest-series-product/.meta/example.php
+++ b/exercises/practice/largest-series-product/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/largest-series-product/LargestSeriesProduct.php b/exercises/practice/largest-series-product/LargestSeriesProduct.php
index 9653e722..154e0377 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProduct.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProduct.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/largest-series-product/LargestSeriesProductTest.php b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
index f5acb3d3..5e5c2034 100644
--- a/exercises/practice/largest-series-product/LargestSeriesProductTest.php
+++ b/exercises/practice/largest-series-product/LargestSeriesProductTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/leap/.meta/example.php b/exercises/practice/leap/.meta/example.php
index 59b83d52..c30d694a 100644
--- a/exercises/practice/leap/.meta/example.php
+++ b/exercises/practice/leap/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/leap/Leap.php b/exercises/practice/leap/Leap.php
index 54946e90..36f23da2 100644
--- a/exercises/practice/leap/Leap.php
+++ b/exercises/practice/leap/Leap.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/leap/LeapTest.php b/exercises/practice/leap/LeapTest.php
index 1d16a84d..b901b55e 100644
--- a/exercises/practice/leap/LeapTest.php
+++ b/exercises/practice/leap/LeapTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/luhn/.meta/example.php b/exercises/practice/luhn/.meta/example.php
index 25fc5a8f..01ccc7e5 100644
--- a/exercises/practice/luhn/.meta/example.php
+++ b/exercises/practice/luhn/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/luhn/Luhn.php b/exercises/practice/luhn/Luhn.php
index ca0ab7ed..e075e550 100644
--- a/exercises/practice/luhn/Luhn.php
+++ b/exercises/practice/luhn/Luhn.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/luhn/LuhnTest.php b/exercises/practice/luhn/LuhnTest.php
index cdc2f5c2..36632b44 100644
--- a/exercises/practice/luhn/LuhnTest.php
+++ b/exercises/practice/luhn/LuhnTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/markdown/.meta/example.php b/exercises/practice/markdown/.meta/example.php
index e50865f0..5f3a447c 100644
--- a/exercises/practice/markdown/.meta/example.php
+++ b/exercises/practice/markdown/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/markdown/Markdown.php b/exercises/practice/markdown/Markdown.php
index d3959fcc..961d8914 100644
--- a/exercises/practice/markdown/Markdown.php
+++ b/exercises/practice/markdown/Markdown.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/markdown/MarkdownTest.php b/exercises/practice/markdown/MarkdownTest.php
index f0c7111e..e069db94 100644
--- a/exercises/practice/markdown/MarkdownTest.php
+++ b/exercises/practice/markdown/MarkdownTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/mask-credit-card/.meta/example.php b/exercises/practice/mask-credit-card/.meta/example.php
index 3bdce85d..ec364a42 100644
--- a/exercises/practice/mask-credit-card/.meta/example.php
+++ b/exercises/practice/mask-credit-card/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/mask-credit-card/MaskCreditCard.php b/exercises/practice/mask-credit-card/MaskCreditCard.php
index 237767b1..e436a1b2 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCard.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCard.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/mask-credit-card/MaskCreditCardTest.php b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
index f6b6796d..8610a674 100644
--- a/exercises/practice/mask-credit-card/MaskCreditCardTest.php
+++ b/exercises/practice/mask-credit-card/MaskCreditCardTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/matching-brackets/.meta/example.php b/exercises/practice/matching-brackets/.meta/example.php
index d56111b5..8650fe7a 100644
--- a/exercises/practice/matching-brackets/.meta/example.php
+++ b/exercises/practice/matching-brackets/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/matching-brackets/MatchingBrackets.php b/exercises/practice/matching-brackets/MatchingBrackets.php
index 9541f581..01f5f01a 100644
--- a/exercises/practice/matching-brackets/MatchingBrackets.php
+++ b/exercises/practice/matching-brackets/MatchingBrackets.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/matching-brackets/MatchingBracketsTest.php b/exercises/practice/matching-brackets/MatchingBracketsTest.php
index 49bd6214..e89f0122 100644
--- a/exercises/practice/matching-brackets/MatchingBracketsTest.php
+++ b/exercises/practice/matching-brackets/MatchingBracketsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/meetup/.meta/example.php b/exercises/practice/meetup/.meta/example.php
index fa8c606b..3072d0b4 100644
--- a/exercises/practice/meetup/.meta/example.php
+++ b/exercises/practice/meetup/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/meetup/Meetup.php b/exercises/practice/meetup/Meetup.php
index 9bb10314..471ff548 100644
--- a/exercises/practice/meetup/Meetup.php
+++ b/exercises/practice/meetup/Meetup.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/meetup/MeetupTest.php b/exercises/practice/meetup/MeetupTest.php
index 12b10112..ec602455 100644
--- a/exercises/practice/meetup/MeetupTest.php
+++ b/exercises/practice/meetup/MeetupTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/minesweeper/.meta/example.php b/exercises/practice/minesweeper/.meta/example.php
index 0e65340d..8bb42129 100644
--- a/exercises/practice/minesweeper/.meta/example.php
+++ b/exercises/practice/minesweeper/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/minesweeper/Minesweeper.php b/exercises/practice/minesweeper/Minesweeper.php
index 73ce2b62..5ffee1e2 100644
--- a/exercises/practice/minesweeper/Minesweeper.php
+++ b/exercises/practice/minesweeper/Minesweeper.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/minesweeper/MinesweeperTest.php b/exercises/practice/minesweeper/MinesweeperTest.php
index 1b1e2b65..e4d3dedc 100644
--- a/exercises/practice/minesweeper/MinesweeperTest.php
+++ b/exercises/practice/minesweeper/MinesweeperTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nth-prime/.meta/example.php b/exercises/practice/nth-prime/.meta/example.php
index d0e38d0d..17d2c8fc 100644
--- a/exercises/practice/nth-prime/.meta/example.php
+++ b/exercises/practice/nth-prime/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nth-prime/NthPrime.php b/exercises/practice/nth-prime/NthPrime.php
index 8a4e936c..cad25236 100644
--- a/exercises/practice/nth-prime/NthPrime.php
+++ b/exercises/practice/nth-prime/NthPrime.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nth-prime/NthPrimeTest.php b/exercises/practice/nth-prime/NthPrimeTest.php
index 9bca8f2d..a36ba998 100644
--- a/exercises/practice/nth-prime/NthPrimeTest.php
+++ b/exercises/practice/nth-prime/NthPrimeTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nucleotide-count/.meta/example.php b/exercises/practice/nucleotide-count/.meta/example.php
index 7a9cf5c4..5915a24f 100644
--- a/exercises/practice/nucleotide-count/.meta/example.php
+++ b/exercises/practice/nucleotide-count/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nucleotide-count/NucleotideCount.php b/exercises/practice/nucleotide-count/NucleotideCount.php
index 7378a3f3..77d459a3 100644
--- a/exercises/practice/nucleotide-count/NucleotideCount.php
+++ b/exercises/practice/nucleotide-count/NucleotideCount.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/nucleotide-count/NucleotideCountTest.php b/exercises/practice/nucleotide-count/NucleotideCountTest.php
index a6412b79..50ba9419 100644
--- a/exercises/practice/nucleotide-count/NucleotideCountTest.php
+++ b/exercises/practice/nucleotide-count/NucleotideCountTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ocr-numbers/.meta/example.php b/exercises/practice/ocr-numbers/.meta/example.php
index bfbd6118..0fdd8434 100644
--- a/exercises/practice/ocr-numbers/.meta/example.php
+++ b/exercises/practice/ocr-numbers/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ocr-numbers/OcrNumbers.php b/exercises/practice/ocr-numbers/OcrNumbers.php
index ae46bc2e..00be91b5 100644
--- a/exercises/practice/ocr-numbers/OcrNumbers.php
+++ b/exercises/practice/ocr-numbers/OcrNumbers.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ocr-numbers/OcrNumbersTest.php b/exercises/practice/ocr-numbers/OcrNumbersTest.php
index 7014524e..69145a15 100644
--- a/exercises/practice/ocr-numbers/OcrNumbersTest.php
+++ b/exercises/practice/ocr-numbers/OcrNumbersTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ordinal-number/.meta/example.php b/exercises/practice/ordinal-number/.meta/example.php
index 75913b33..e0ce3e25 100644
--- a/exercises/practice/ordinal-number/.meta/example.php
+++ b/exercises/practice/ordinal-number/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ordinal-number/OrdinalNumber.php b/exercises/practice/ordinal-number/OrdinalNumber.php
index 7ba9134f..b2c4bdd2 100644
--- a/exercises/practice/ordinal-number/OrdinalNumber.php
+++ b/exercises/practice/ordinal-number/OrdinalNumber.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/ordinal-number/OrdinalNumberTest.php b/exercises/practice/ordinal-number/OrdinalNumberTest.php
index 54e7275f..a3f0cf33 100644
--- a/exercises/practice/ordinal-number/OrdinalNumberTest.php
+++ b/exercises/practice/ordinal-number/OrdinalNumberTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/palindrome-products/.meta/example.php b/exercises/practice/palindrome-products/.meta/example.php
index a27a6ff4..0cf31d8e 100644
--- a/exercises/practice/palindrome-products/.meta/example.php
+++ b/exercises/practice/palindrome-products/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/palindrome-products/PalindromeProducts.php b/exercises/practice/palindrome-products/PalindromeProducts.php
index b4485a06..d9aaa41e 100644
--- a/exercises/practice/palindrome-products/PalindromeProducts.php
+++ b/exercises/practice/palindrome-products/PalindromeProducts.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/palindrome-products/PalindromeProductsTest.php b/exercises/practice/palindrome-products/PalindromeProductsTest.php
index ce4e464c..b73c2a81 100644
--- a/exercises/practice/palindrome-products/PalindromeProductsTest.php
+++ b/exercises/practice/palindrome-products/PalindromeProductsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pangram/.meta/example.php b/exercises/practice/pangram/.meta/example.php
index 6c2e9879..061c2be1 100644
--- a/exercises/practice/pangram/.meta/example.php
+++ b/exercises/practice/pangram/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pangram/Pangram.php b/exercises/practice/pangram/Pangram.php
index 812248ba..78592055 100644
--- a/exercises/practice/pangram/Pangram.php
+++ b/exercises/practice/pangram/Pangram.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pangram/PangramTest.php b/exercises/practice/pangram/PangramTest.php
index 366ad623..764de683 100644
--- a/exercises/practice/pangram/PangramTest.php
+++ b/exercises/practice/pangram/PangramTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pascals-triangle/.meta/example.php b/exercises/practice/pascals-triangle/.meta/example.php
index 27be7e1a..1a5cb38a 100644
--- a/exercises/practice/pascals-triangle/.meta/example.php
+++ b/exercises/practice/pascals-triangle/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pascals-triangle/PascalsTriangle.php b/exercises/practice/pascals-triangle/PascalsTriangle.php
index 4d675d69..ab3fd49d 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangle.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangle.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pascals-triangle/PascalsTriangleTest.php b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
index 790c218f..e447976b 100644
--- a/exercises/practice/pascals-triangle/PascalsTriangleTest.php
+++ b/exercises/practice/pascals-triangle/PascalsTriangleTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/perfect-numbers/.meta/example.php b/exercises/practice/perfect-numbers/.meta/example.php
index a588445f..e4fa47e0 100644
--- a/exercises/practice/perfect-numbers/.meta/example.php
+++ b/exercises/practice/perfect-numbers/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/perfect-numbers/PerfectNumbers.php b/exercises/practice/perfect-numbers/PerfectNumbers.php
index c26a53b1..34c6a4f1 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbers.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbers.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/perfect-numbers/PerfectNumbersTest.php b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
index b83b3c08..03adacd8 100644
--- a/exercises/practice/perfect-numbers/PerfectNumbersTest.php
+++ b/exercises/practice/perfect-numbers/PerfectNumbersTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/phone-number/.meta/example.php b/exercises/practice/phone-number/.meta/example.php
index b91fc9a6..04c2e101 100644
--- a/exercises/practice/phone-number/.meta/example.php
+++ b/exercises/practice/phone-number/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/phone-number/PhoneNumber.php b/exercises/practice/phone-number/PhoneNumber.php
index df58a7fe..dcdd8e50 100644
--- a/exercises/practice/phone-number/PhoneNumber.php
+++ b/exercises/practice/phone-number/PhoneNumber.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/phone-number/PhoneNumberTest.php b/exercises/practice/phone-number/PhoneNumberTest.php
index f9abfc91..49cda21d 100644
--- a/exercises/practice/phone-number/PhoneNumberTest.php
+++ b/exercises/practice/phone-number/PhoneNumberTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pig-latin/.meta/example.php b/exercises/practice/pig-latin/.meta/example.php
index 73d5047e..d3d29828 100644
--- a/exercises/practice/pig-latin/.meta/example.php
+++ b/exercises/practice/pig-latin/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pig-latin/PigLatin.php b/exercises/practice/pig-latin/PigLatin.php
index 4fc3eef2..a5938933 100644
--- a/exercises/practice/pig-latin/PigLatin.php
+++ b/exercises/practice/pig-latin/PigLatin.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/pig-latin/PigLatinTest.php b/exercises/practice/pig-latin/PigLatinTest.php
index 0b2ff82f..948e803f 100644
--- a/exercises/practice/pig-latin/PigLatinTest.php
+++ b/exercises/practice/pig-latin/PigLatinTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/prime-factors/.meta/example.php b/exercises/practice/prime-factors/.meta/example.php
index 1771c5b7..7a817641 100644
--- a/exercises/practice/prime-factors/.meta/example.php
+++ b/exercises/practice/prime-factors/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/prime-factors/PrimeFactors.php b/exercises/practice/prime-factors/PrimeFactors.php
index ec760a27..033fe0f6 100644
--- a/exercises/practice/prime-factors/PrimeFactors.php
+++ b/exercises/practice/prime-factors/PrimeFactors.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/prime-factors/PrimeFactorsTest.php b/exercises/practice/prime-factors/PrimeFactorsTest.php
index 7f5164cc..394fa01a 100644
--- a/exercises/practice/prime-factors/PrimeFactorsTest.php
+++ b/exercises/practice/prime-factors/PrimeFactorsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/queen-attack/.meta/example.php b/exercises/practice/queen-attack/.meta/example.php
index 4341bf61..bff6c287 100644
--- a/exercises/practice/queen-attack/.meta/example.php
+++ b/exercises/practice/queen-attack/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/queen-attack/QueenAttack.php b/exercises/practice/queen-attack/QueenAttack.php
index 8be77363..e2a5af09 100644
--- a/exercises/practice/queen-attack/QueenAttack.php
+++ b/exercises/practice/queen-attack/QueenAttack.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/queen-attack/QueenAttackTest.php b/exercises/practice/queen-attack/QueenAttackTest.php
index 6ae085ba..af3da5cd 100644
--- a/exercises/practice/queen-attack/QueenAttackTest.php
+++ b/exercises/practice/queen-attack/QueenAttackTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rail-fence-cipher/.meta/example.php b/exercises/practice/rail-fence-cipher/.meta/example.php
index d9ee6023..6d15f309 100644
--- a/exercises/practice/rail-fence-cipher/.meta/example.php
+++ b/exercises/practice/rail-fence-cipher/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipher.php b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
index b9e74b92..522ee397 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipher.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipher.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
index 08eef014..b344f238 100644
--- a/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
+++ b/exercises/practice/rail-fence-cipher/RailFenceCipherTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/raindrops/.meta/example.php b/exercises/practice/raindrops/.meta/example.php
index cad041ee..485af00a 100644
--- a/exercises/practice/raindrops/.meta/example.php
+++ b/exercises/practice/raindrops/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/raindrops/Raindrops.php b/exercises/practice/raindrops/Raindrops.php
index 8d52fc28..39b0c2d4 100644
--- a/exercises/practice/raindrops/Raindrops.php
+++ b/exercises/practice/raindrops/Raindrops.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/raindrops/RaindropsTest.php b/exercises/practice/raindrops/RaindropsTest.php
index 0d3591c6..4958bfa9 100644
--- a/exercises/practice/raindrops/RaindropsTest.php
+++ b/exercises/practice/raindrops/RaindropsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rna-transcription/.meta/example.php b/exercises/practice/rna-transcription/.meta/example.php
index 4dc49afa..cc1b1255 100644
--- a/exercises/practice/rna-transcription/.meta/example.php
+++ b/exercises/practice/rna-transcription/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rna-transcription/RnaTranscription.php b/exercises/practice/rna-transcription/RnaTranscription.php
index b2aff733..70328d50 100644
--- a/exercises/practice/rna-transcription/RnaTranscription.php
+++ b/exercises/practice/rna-transcription/RnaTranscription.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/rna-transcription/RnaTranscriptionTest.php b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
index 164037d9..09b8be15 100644
--- a/exercises/practice/rna-transcription/RnaTranscriptionTest.php
+++ b/exercises/practice/rna-transcription/RnaTranscriptionTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-name/.meta/example.php b/exercises/practice/robot-name/.meta/example.php
index ff14c497..d9edb40b 100644
--- a/exercises/practice/robot-name/.meta/example.php
+++ b/exercises/practice/robot-name/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-name/RobotName.php b/exercises/practice/robot-name/RobotName.php
index f1b2a0a1..3f7fd53d 100644
--- a/exercises/practice/robot-name/RobotName.php
+++ b/exercises/practice/robot-name/RobotName.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-name/RobotNameTest.php b/exercises/practice/robot-name/RobotNameTest.php
index d740e00b..ae360996 100644
--- a/exercises/practice/robot-name/RobotNameTest.php
+++ b/exercises/practice/robot-name/RobotNameTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-simulator/.meta/example.php b/exercises/practice/robot-simulator/.meta/example.php
index b4e50bc9..2629ab10 100644
--- a/exercises/practice/robot-simulator/.meta/example.php
+++ b/exercises/practice/robot-simulator/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-simulator/RobotSimulator.php b/exercises/practice/robot-simulator/RobotSimulator.php
index f1538e05..d4305ab9 100644
--- a/exercises/practice/robot-simulator/RobotSimulator.php
+++ b/exercises/practice/robot-simulator/RobotSimulator.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/robot-simulator/RobotSimulatorTest.php b/exercises/practice/robot-simulator/RobotSimulatorTest.php
index d58e866c..0761cc42 100644
--- a/exercises/practice/robot-simulator/RobotSimulatorTest.php
+++ b/exercises/practice/robot-simulator/RobotSimulatorTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/roman-numerals/.meta/example.php b/exercises/practice/roman-numerals/.meta/example.php
index f33ba8f9..83ebd3d0 100644
--- a/exercises/practice/roman-numerals/.meta/example.php
+++ b/exercises/practice/roman-numerals/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/roman-numerals/RomanNumerals.php b/exercises/practice/roman-numerals/RomanNumerals.php
index 569aa078..99da717a 100644
--- a/exercises/practice/roman-numerals/RomanNumerals.php
+++ b/exercises/practice/roman-numerals/RomanNumerals.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/roman-numerals/RomanNumeralsTest.php b/exercises/practice/roman-numerals/RomanNumeralsTest.php
index f5b042e5..b0605d9e 100644
--- a/exercises/practice/roman-numerals/RomanNumeralsTest.php
+++ b/exercises/practice/roman-numerals/RomanNumeralsTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/run-length-encoding/.meta/example.php b/exercises/practice/run-length-encoding/.meta/example.php
index 9e8c5295..3965acb4 100644
--- a/exercises/practice/run-length-encoding/.meta/example.php
+++ b/exercises/practice/run-length-encoding/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/run-length-encoding/RunLengthEncoding.php b/exercises/practice/run-length-encoding/RunLengthEncoding.php
index 72a5ab68..82d354b1 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncoding.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncoding.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
index 0a08db31..c1477360 100644
--- a/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
+++ b/exercises/practice/run-length-encoding/RunLengthEncodingTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/scrabble-score/.meta/example.php b/exercises/practice/scrabble-score/.meta/example.php
index 5e96f540..072ff3ef 100644
--- a/exercises/practice/scrabble-score/.meta/example.php
+++ b/exercises/practice/scrabble-score/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/scrabble-score/ScrabbleScore.php b/exercises/practice/scrabble-score/ScrabbleScore.php
index deeb9cc0..e835b020 100644
--- a/exercises/practice/scrabble-score/ScrabbleScore.php
+++ b/exercises/practice/scrabble-score/ScrabbleScore.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/scrabble-score/ScrabbleScoreTest.php b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
index e5edcdd0..e4e2f7f6 100644
--- a/exercises/practice/scrabble-score/ScrabbleScoreTest.php
+++ b/exercises/practice/scrabble-score/ScrabbleScoreTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/series/.meta/example.php b/exercises/practice/series/.meta/example.php
index 0ed5804d..553caa3c 100644
--- a/exercises/practice/series/.meta/example.php
+++ b/exercises/practice/series/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/series/Series.php b/exercises/practice/series/Series.php
index 70c5968f..5f708a29 100644
--- a/exercises/practice/series/Series.php
+++ b/exercises/practice/series/Series.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/series/SeriesTest.php b/exercises/practice/series/SeriesTest.php
index 4e196e5c..808c16f0 100644
--- a/exercises/practice/series/SeriesTest.php
+++ b/exercises/practice/series/SeriesTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sieve/.meta/example.php b/exercises/practice/sieve/.meta/example.php
index bd013081..3997abc6 100644
--- a/exercises/practice/sieve/.meta/example.php
+++ b/exercises/practice/sieve/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sieve/Sieve.php b/exercises/practice/sieve/Sieve.php
index 7cb5a50d..c4d482d3 100644
--- a/exercises/practice/sieve/Sieve.php
+++ b/exercises/practice/sieve/Sieve.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sieve/SieveTest.php b/exercises/practice/sieve/SieveTest.php
index 6d387565..02a2d986 100644
--- a/exercises/practice/sieve/SieveTest.php
+++ b/exercises/practice/sieve/SieveTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/space-age/.meta/example.php b/exercises/practice/space-age/.meta/example.php
index dc727392..363e13ed 100644
--- a/exercises/practice/space-age/.meta/example.php
+++ b/exercises/practice/space-age/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/space-age/SpaceAge.php b/exercises/practice/space-age/SpaceAge.php
index 95913d42..aa15c2e1 100644
--- a/exercises/practice/space-age/SpaceAge.php
+++ b/exercises/practice/space-age/SpaceAge.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/space-age/SpaceAgeTest.php b/exercises/practice/space-age/SpaceAgeTest.php
index 2412ad78..35dc10a1 100644
--- a/exercises/practice/space-age/SpaceAgeTest.php
+++ b/exercises/practice/space-age/SpaceAgeTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sum-of-multiples/.meta/example.php b/exercises/practice/sum-of-multiples/.meta/example.php
index 9533f23d..fbf0f0b0 100644
--- a/exercises/practice/sum-of-multiples/.meta/example.php
+++ b/exercises/practice/sum-of-multiples/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiples.php b/exercises/practice/sum-of-multiples/SumOfMultiples.php
index 0a34e3f1..3bdd29c4 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiples.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiples.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
index 0699b343..f69255ba 100644
--- a/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
+++ b/exercises/practice/sum-of-multiples/SumOfMultiplesTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/transpose/.meta/example.php b/exercises/practice/transpose/.meta/example.php
index 771c3a9c..98f4aa98 100644
--- a/exercises/practice/transpose/.meta/example.php
+++ b/exercises/practice/transpose/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/transpose/Transpose.php b/exercises/practice/transpose/Transpose.php
index 257ebd33..058c88cb 100644
--- a/exercises/practice/transpose/Transpose.php
+++ b/exercises/practice/transpose/Transpose.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/transpose/TransposeTest.php b/exercises/practice/transpose/TransposeTest.php
index e64f13bd..7e46d39f 100644
--- a/exercises/practice/transpose/TransposeTest.php
+++ b/exercises/practice/transpose/TransposeTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/triangle/.meta/example.php b/exercises/practice/triangle/.meta/example.php
index 70ef41ca..f9d09a54 100644
--- a/exercises/practice/triangle/.meta/example.php
+++ b/exercises/practice/triangle/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/triangle/Triangle.php b/exercises/practice/triangle/Triangle.php
index 28ff1e53..85fde79f 100644
--- a/exercises/practice/triangle/Triangle.php
+++ b/exercises/practice/triangle/Triangle.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/triangle/TriangleTest.php b/exercises/practice/triangle/TriangleTest.php
index 0523f3c9..b19f727f 100644
--- a/exercises/practice/triangle/TriangleTest.php
+++ b/exercises/practice/triangle/TriangleTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/trinary/.meta/example.php b/exercises/practice/trinary/.meta/example.php
index 4b7f2986..67c0115b 100644
--- a/exercises/practice/trinary/.meta/example.php
+++ b/exercises/practice/trinary/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/trinary/Trinary.php b/exercises/practice/trinary/Trinary.php
index d454597a..e37a4874 100644
--- a/exercises/practice/trinary/Trinary.php
+++ b/exercises/practice/trinary/Trinary.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/trinary/TrinaryTest.php b/exercises/practice/trinary/TrinaryTest.php
index 598dc2f4..85c2b566 100644
--- a/exercises/practice/trinary/TrinaryTest.php
+++ b/exercises/practice/trinary/TrinaryTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/two-fer/.meta/example.php b/exercises/practice/two-fer/.meta/example.php
index 197bb96c..c5fc79c3 100644
--- a/exercises/practice/two-fer/.meta/example.php
+++ b/exercises/practice/two-fer/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/two-fer/TwoFer.php b/exercises/practice/two-fer/TwoFer.php
index 8d014552..7205ef1d 100644
--- a/exercises/practice/two-fer/TwoFer.php
+++ b/exercises/practice/two-fer/TwoFer.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/two-fer/TwoFerTest.php b/exercises/practice/two-fer/TwoFerTest.php
index fcbd3a66..c0807d65 100644
--- a/exercises/practice/two-fer/TwoFerTest.php
+++ b/exercises/practice/two-fer/TwoFerTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/variable-length-quantity/.meta/example.php b/exercises/practice/variable-length-quantity/.meta/example.php
index 409bf97b..c11a2487 100644
--- a/exercises/practice/variable-length-quantity/.meta/example.php
+++ b/exercises/practice/variable-length-quantity/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
index 22863d03..c7a05449 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantity.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
index 017d2bc6..279c21d0 100644
--- a/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
+++ b/exercises/practice/variable-length-quantity/VariableLengthQuantityTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/word-count/.meta/example.php b/exercises/practice/word-count/.meta/example.php
index 7e9b6bd3..0282ae35 100644
--- a/exercises/practice/word-count/.meta/example.php
+++ b/exercises/practice/word-count/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/word-count/WordCount.php b/exercises/practice/word-count/WordCount.php
index c674b029..b782967b 100644
--- a/exercises/practice/word-count/WordCount.php
+++ b/exercises/practice/word-count/WordCount.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/word-count/WordCountTest.php b/exercises/practice/word-count/WordCountTest.php
index e0250c14..21c6ad84 100644
--- a/exercises/practice/word-count/WordCountTest.php
+++ b/exercises/practice/word-count/WordCountTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/wordy/.meta/example.php b/exercises/practice/wordy/.meta/example.php
index e3d21291..dc368102 100644
--- a/exercises/practice/wordy/.meta/example.php
+++ b/exercises/practice/wordy/.meta/example.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/wordy/Wordy.php b/exercises/practice/wordy/Wordy.php
index 039b7244..5f0b8aed 100644
--- a/exercises/practice/wordy/Wordy.php
+++ b/exercises/practice/wordy/Wordy.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/exercises/practice/wordy/WordyTest.php b/exercises/practice/wordy/WordyTest.php
index 42414fbc..f90b1b70 100644
--- a/exercises/practice/wordy/WordyTest.php
+++ b/exercises/practice/wordy/WordyTest.php
@@ -1,18 +1,24 @@
 <?php
 
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 
diff --git a/src/Sniffs/ExplainStrictTypesSniff.php b/src/Sniffs/ExplainStrictTypesSniff.php
index 1fbd87a4..5b9a4d31 100644
--- a/src/Sniffs/ExplainStrictTypesSniff.php
+++ b/src/Sniffs/ExplainStrictTypesSniff.php
@@ -12,18 +12,24 @@ class ExplainStrictTypesSniff implements Sniff
 {
     private static string $explanation = <<<EOT
 /*
- * By adding type hints and enabling strict type checking, code can become easier to read,
- * self-documenting and reduce the number of potential bugs.
- * By default, type declarations are non-strict, which means they will attempt to
- * change the original type to match the type specified by the type-declaration.
+ * By adding type hints and enabling strict type checking, code can become
+ * easier to read, self-documenting and reduce the number of potential bugs.
+ * By default, type declarations are non-strict, which means they will attempt
+ * to change the original type to match the type specified by the
+ * type-declaration.
+ *
  * In other words, if you pass a string to a function requiring a float,
  * it will attempt to convert the string value to a float.
- * To enable strict mode, a single declare directive must be placed at the top of the file.
+ *
+ * To enable strict mode, a single declare directive must be placed at the top
+ * of the file.
  * This means that the strictness of typing is configured on a per-file basis.
- * This directive not only affects the type declarations of parameters, but also a function's
- * return type.
+ * This directive not only affects the type declarations of parameters, but also
+ * a function's return type.
+ *
+ * For more info review the Concept on strict type checking in the PHP track
+ * <link>.
  *
- * For more info review the Concept on strict type checking in the PHP track <link>.
  * To disable strict typing, comment out the directive below.
  */
 EOT;