SHA-256 is a SHA-2 cryptographic hash function producing a 256-bit digest. It processes a padded message in 512-bit blocks, with eight 32-bit state words and 64 processing rounds per block. The specified additions use modular arithmetic modulo $2^{32}$.^[ref]

Padding is part of the function. For input bit length $\ell <2^{64}$, append a one bit, then the smallest nonnegative number $k$ of zero bits satisfyingthen append the 64-bit representation of $\ell$. This makes the complete length a multiple of 512 bits.^[ref]

For an original byte-count example, the three ASCII bytes 61 62 63 have length 24 bits. Here $k=423$, andThe padded block consists of the original three bytes, byte 80, 52 zero bytes and an eight-byte length field representing 24. The padded input occupies 64 bytes; the final digest occupies 32 bytes. Computing SHA-256 gives

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad.

Adding a newline changes the byte sequence and the digest. Displayed text, its character encoding and its line terminator must therefore be specified when comparing hash values.

The padding boundary is also visible without computing a digest. A 55-byte input fits its padding into one 64-byte block, whereas a 56-byte input requires two blocks because the length field no longer fits. Both still produce a 256-bit output. Digest length is not the padded-message length or a reversible compressed representation of the input.

Finite output size necessarily allows collisions over a larger input set; collision resistance concerns the difficulty of finding them. SHA-256 also supplies the hash operation used inside common HMAC and HKDF instantiations, whose keyed constructions and security properties differ from an ordinary unkeyed digest.

SHA-224 is a SHA-2 cryptographic hash function producing a 224-bit digest. It follows the SHA-256 computation with a different hash initialization vector and a final output shortened to its first seven 32-bit state words.^[ref]

If the final state words are $H_0,\dots ,H_7$, the digest isThis is $7\times 32=224$ bits, or 28 bytes and 56 hexadecimal digits. The input is still padded into 512-bit blocks, and each block still undergoes the SHA-256 family's 64-round computation. Output width and internal processing width are different quantities.

For a computed example, the ASCII bytes 61 62 63 give

23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7.

A SHA-256 digest of the same bytes begins ba7816bf8f01cfea. Keeping only its first 28 bytes therefore does not give SHA-224. The algorithm's different initial values are applied before processing any message block.

The same output length also does not make SHA-224 identical to SHA-512/224. The latter uses the 64-bit SHA-512 family structure, a different initial state and a different padding/length-field convention. For instance, a 56-byte input takes two padded blocks in SHA-224 but only one in the SHA-512-based variant. Both results have 28 bytes, so a digest field's size cannot identify which function produced it.

The intended cryptographic protocol must select the hash explicitly. A cryptographic test vector for SHA-224 checks that defined function, whereas an HMAC vector also specifies its key and keyed construction.

SHA-384 is a SHA-2 cryptographic hash function producing 384 bits. It uses the 64-bit word operations, 1024-bit blocks and eighty-round computation of SHA-512, with its own hash initialization vector. Its result is the first 384 bits of that differently initialized computation.^[ref]

Write its final eight-word state as $H_0,\dots ,H_7$, with each word containing 64 bits. The output iswhere $\Vert$ denotes concatenation. Six words give $6\times 64=384$ bits, or 48 bytes and 96 hexadecimal digits. The computation still maintains eight state words while processing the message; the shorter output does not reduce every intermediate state to six words.

For a computed example using ASCII bytes 61 62 63, SHA-384 gives

cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7.

The ordinary SHA-512 digest begins ddaf35a193617aba, so truncating that digest to 48 bytes already disagrees at the beginning. Different initialization, rather than merely a shorter printed result, distinguishes the algorithms.

A streaming implementation can process message blocks using the SHA-512 family machinery while retaining the selected variant's initial state and final serialization. Treating those choices as part of the function is essential when a digital signature or HMAC specification names SHA-384. Changing to another 384-bit output transformation changes the algorithm, even if the receiving buffer still has the expected size.

SHA-512 is a SHA-2 cryptographic hash function with a 512-bit digest. It processes 1024-bit message blocks through eighty rounds using eight 64-bit state words and additions modulo $2^{64}$. Its message-length field is 128 bits.^[ref]

For bit length $\ell <2^{128}$, padding appends one bit and $k$ zero bits so thatthen appends the 128-bit original length. The hash initialization vector is fixed by the algorithm; it is not a fresh secret for each message. The padded blocks update the state in order, and the final eight words form the digest.

For a computed example, hash the three ASCII bytes 61 62 63. Here $\ell =24$, so $k=871$ and $24+1+871+128=1024$. One padded 128-byte block is processed. Its digest, in hexadecimal, is

ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f.

The 128 hexadecimal digits represent 64 bytes. They do not represent the 128-byte padded input. For another padding-count example, 111 input bytes fit into one padded block, while 112 input bytes require two; the digest remains 64 bytes in either case.

SHA-384, SHA-512/224 and SHA-512/256 reuse the SHA-512 compression structure but have specified different initial states and output rules. Taking a prefix of an ordinary SHA-512 digest therefore does not implement those algorithms. A cryptographic test vector must identify the exact hash, input encoding and expected output rather than only a digest length.

SHA-512/224 is a SHA-2 cryptographic hash function returning 224 bits. It uses the SHA-512 computation with its own hash initialization vector and outputs the first 224 bits of the final state. The SHA-512/t initialization procedure uses the ASCII label SHA-512/224, so its initial state differs from that of SHA-512/256 as well as ordinary SHA-512.^[ref]

Output serialization needs care because $224=3\times 64+32$. If the final eight 64-bit words are $H_0,\dots ,H_7$, the digest containswhere $\Vert$ denotes concatenation in the standard's most-significant-bit-first order. It has 28 bytes, or 56 hexadecimal digits. For a simple serialization example, if $H_3$ were 89abcdef01234567, its contribution would be the four bytes 89 ab cd ef. Taking the four bytes 01 23 45 67 would keep the wrong half. An implementation's machine endianness does not change the specified digest bytes.

For a computed example, hashing ASCII bytes 61 62 63 gives

4634270f707b6a54daae7530460842e20e37ed265ceee9a43e8924aa.

SHA-224 of the same bytes begins 23097d223405d822, despite having the same 224-bit output size. The two functions use different compression structures, initial states and message-padding conventions. Taking a prefix of the ordinary SHA-512 digest also gives a different result.

The distinction matters in a cryptographic test vector: a 28-byte expected digest cannot identify the intended algorithm by its size alone. The vector must name SHA-512/224 and specify the exact input bytes. The different label used during initialization is fixed by the algorithm; applications do not choose it separately for each hash.

SHA-512/256 is a SHA-2 cryptographic hash function with a 256-bit digest. It uses the 1024-bit blocks and 64-bit word operations of SHA-512, a variant-specific hash initialization vector, and the first 256 bits of the final state. It is one member of SHA-512/t.^[ref]

Its initialization illustrates cryptographic domain separation. Let $v$ be the eight-word ordinary SHA-512 initial state. First form $\tilde{v}$ by applying bitwise exclusive or to each word with the hexadecimal word a5a5a5a5a5a5a5a5. Run the SHA-512 computation on the ASCII label SHA-512/256, using $\tilde{v}$ as its initial state. The full 512-bit result is the variant's fixed initial state $v^{(256)}$. This label computation is part of defining the function, not an extra message prefix chosen by its user.^[ref]

If ${SHA512}^{v^{(256)}}(m)$ denotes the full final state obtained by hashing $m$ with that initialization, thenThe output comprises four 64-bit words: 32 bytes or 64 hexadecimal digits. The initial state is public and fixed; it is not a cryptographic salt or a secret key.

For a computed example, the three ASCII bytes 61 62 63 give

53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23.

Ordinary SHA-512 of those bytes begins ddaf35a193617aba, while SHA-256 begins ba7816bf8f01cfea. Neither output implements SHA-512/256. In particular, the slash and output width do not mean “hash with ordinary SHA-512 and keep 256 bits”.

The padding also follows the SHA-512 family: a 128-bit length field and 1024-bit blocks. An input of 56 bytes therefore fits into one padded block here, while SHA-256 needs two of its smaller blocks. The identical 32-byte digest sizes say nothing about those different computations.

SHA-512/t is the family of $t$-bit cryptographic hash functions built using the SHA-512 computation with a $t$-specific hash initialization vector and final truncation. The FIPS 180-4 construction takes a positive integer $t<512$, excluding $t=384$; SHA-384 has its separately specified initialization. The 2015 standard explicitly specifies SHA-512/224 and SHA-512/256 as the approved members, rather than treating every permissible parameter as a standardized choice.^[ref]

The initialization procedure first XORs each ordinary SHA-512 initial word with hexadecimal a5a5a5a5a5a5a5a5. It then hashes the ASCII label SHA-512/t, replacing t with its decimal value without leading zeros, using that modified initial state. The resulting full 512-bit value becomes the selected member's fixed initial state.^[ref]

For a concrete word calculation,where $\oplus$ denotes bitwise exclusive or. All eight words are modified, not just this first one. At $t=256$, the label is the eleven ASCII bytes 53 48 41 2d 35 31 32 2f 32 35 36. At $t=224$, its final three bytes are instead 32 32 34. The slash is an actual label byte, not a division operation or a parser instruction.

The generated initial state's first word is 22312194fc2bf72c for SHA-512/256 and 8c3d37c819544da2 for SHA-512/224. These fixed values separate the algorithms before the user's message is processed. Hashing the label with ordinary SHA-512 initialization would follow a different procedure.^[ref]

After processing the message with its member-specific initialization, retain the first $t$ bits of the final state. For an abstract $t=13$ serialization exercise, a state beginning with bytes ab cd would yield bits 1010101111001; the lower three bits of the second byte are excluded. This illustrates bit truncation, not a recommendation to use a 13-bit digest. Output length, initialization and protocol selection all remain part of the algorithm's identity.

The X chromosome is a sex chromosome in the human and many other mammalian chromosome systems. Typical human XX cells contain two copies and typical XY cells contain one. Many genes on the X chromosome participate in functions beyond sex determination, so its inheritance can influence a wide range of phenotypes.^[ref]

For an illustrative recessive allele in a region without an equivalent functional copy on the Y chromosome, an XY individual has only the one X-linked copy at that location. An XX individual can carry another allele on the other X chromosome, although X-chromosome inactivation and other biological details affect expression. Thus “recessive” describes a relationship between alleles when both are present; it does not make a single inherited copy biologically invisible. The example explains an inheritance pattern without making every trait on the X chromosome follow one simple rule.

Factor Xa is the activated serine protease derived from Factor X by limited proteolysis. It catalyses cleavage of prothrombin to generate thrombin, an important activation step in coagulation. Efficient conversion is organized by factor Va, calcium and phospholipids.^[ref]

Purified-component experiments varied the phospholipid surface and the presence of factor Va, showing that apparent kinetic parameters depend on how the components assemble. The same amount of factor Xa can therefore produce different reaction rates in different surroundings.^[ref]

For an invented catalytic accounting example, 1 nmol of active factor Xa generates 100 nmol of activated product during an interval. That is 100 product molecules per initial enzyme molecule, demonstrating catalytic reuse rather than one-to-one consumption. The value is not a measured turnover number: a true rate constant requires a specified time, substrate availability and activation pathway.

A muscle spindle is a specialized stretch-sensitive receptor within a skeletal muscle. It contains small intrafusal muscle fibres with sensory endings that report changes in their mechanical state. This supplies proprioception: information about the body's own position and movement, even without seeing the limb.

The receptor is adjustable. Motor input to the intrafusal muscle fibres changes tension within the spindle and can alter the response of its sensory neurons. In a cat soleus experiment, researchers electrically stimulated an individual motor fibre supplying a muscle spindle, then applied a controlled ramp stretch while recording the sensory output. The prior stimulation changed the subsequent burst of impulses.^[ref]

The same imposed movement can therefore produce different sensory signals depending on the spindle's previous activation. A muscle spindle is an actively regulated sensor, rather than a passive ruler reading muscle length independently of neural state.

NV12 is an eight-bit YCbCr semiplanar pixel format with 4:2:0 chroma subsampling. A full-resolution plane holds luma samples. The following plane stores alternating Cb and Cr samples, with half as many sample positions in each spatial direction. Linux specifies ordinary untiled NV12 with adjacent planes; the separately allocated variant is NV12M.^[ref]

For even dimensions $W,H$, active samples occupy $WH$ luma bytes plus $WH/2$ interleaved colour-difference bytes. This is $3WH/2$ bytes, or an average of 12 bits per original pixel. It does not give every pixel its own three-component triple: neighbouring pixels share the lower-resolution colour-difference samples.

For an original address calculation, choose width six, height four and an eight-byte framebuffer stride in both planes. Put the first luma row at address 1000. The luma allocation occupies $4(8)=32$ bytes, so the colour-difference plane starts at 1032 and occupies another $2(8)=16$ bytes. There are 36 active bytes in 48 allocated bytes, including row padding.

With zero-based indices, luma position $(r,c)=(3,5)$ is at $1000+3(8)+5=1029$. Its associated subsampled grid cell has indices $(\lfloor r/2\rfloor ,\lfloor c/2\rfloor )=(1,2)$ in this declared layout. That cell's Cb and Cr bytes are at 1044 and 1045. Colour reconstruction additionally needs a sampling-location and filtering convention; these address calculations alone do not specify it.

The pixel format identifies storage. A decoder must also know the YCbCr matrix and code ranges to interpret the numbers as colour.

NV21 is an eight-bit YCbCr semiplanar pixel format using 4:2:0 chroma subsampling. It has a full-resolution luma plane followed by interleaved colour-difference samples in Cr, Cb order. NV12 uses the reverse pair order, Cb, Cr. The separately allocated Linux variant is NV21M.^[ref]

An original $4\times 2$ tightly stored image has eight luma bytes followed by four colour-difference bytes. Suppose the latter are 200 40 150 90. Under NV21, the two pairs are $(C_r,C_b)=(200,40)$ and $(150,90)$. Reading the same bytes as NV12 instead assigns $(C_b,C_r)=(200,40)$ and $(150,90)$. The buffer length remains correct while its colour-difference channels are exchanged.

Converting this declared NV21 buffer to NV12 requires swapping adjacent bytes in the interleaved plane, giving 40 200 90 150, while retaining the luma data. This is a layout conversion, not a conversion to the RGB color model. The numerical colour interpretation still depends on the declared YCbCr encoding.

The active footprint is $3WH/2$ bytes for even width $W$ and height $H$ under eight-bit 4:2:0 sampling. Framebuffer stride can add padding, so the next row need not start immediately after the last active sample. A converter must apply the actual row and plane boundaries: swapping pairs across padding or across the luma plane would corrupt the image rather than exchange the intended channels.

A germanium detector is a semiconductor detector whose active material is germanium. Radiation deposits energy that produces electron-hole pairs; an applied electric field collects charge and the electronics convert it into a pulse. High-purity germanium instruments are useful for energy spectroscopy because a single absorbed photon can produce many charge carriers. Cooling reduces thermally generated carriers and electronic noise.^[ref]

For a simple charge inventory, let deposited energy be $E$ and the mean energy per electron-hole pair be $w$. With complete charge collection,Using $w=2.96\mathrm{eV}$, the manufacturer's value at77K, an illustrative $E=59.2\mathrm{keV}$ deposit produces about20,000 pairs, corresponding to about $3.20\times 10^{-15}\mathrm{C}$ of collected pulse charge. This is an average conversion, not a claim that every event produces exactly the same carrier count.^[ref]

The apparatus therefore needs more than a piece of germanium: contacts establish a collecting field, a cooled enclosure controls the environment, and a charge-sensitive preamplifier measures the small pulse. A photopeak corresponds to events depositing the full photon energy. Escaping radiation or incomplete charge collection can produce smaller pulses, so a pulse-height distribution must be interpreted with the detector geometry and response.^[ref]

Effortful control concerns deliberate regulation of attention and action, including inhibiting a dominant response and sustaining a less automatic one. It is an aspect of self-regulation, studied through both everyday ratings and performance tasks. These methods sample different settings and demands, so their scores need not be interchangeable.

An original task example gives a child a simple response rule, then asks for a different response when a familiar cue appears. Accuracy can depend on response inhibition, but also on understanding and remembering the rule. A low score therefore does not isolate inhibition without further comparisons. A rating of everyday effortful control instead summarizes behavior across observations and informants.

Clancy Blair and Rachel Peters Razza examined effortful control, executive function and false-belief understanding together in relation to emerging mathematics and literacy performance. Comparing these predictors helps distinguish overlapping constructs; a predictive association alone does not show that training one measured component causes an academic improvement.^[ref]