user41364: The bitcoin wiki describes difficulty target representation as follows:

How is difficulty stored in blocks? Each block stores a packed
representation (called "Bits") for its actual hexadecimal target. The
target can be derived from it via a predefined formula. For example,
if the packed target in the block is 0x1b0404cb, the hexadecimal
target is
0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000
Note that the 0x0404cb value is a signed value in this format. The
largest legal value for this field is 0x7fffff. To make a larger value
you must shift it down one full byte. Also 0x008000 is the smallest
positive valid value.

Why 0x008000 is the smallest positive valid value?

user2306: To explain that, let's look at the code that unpacks the compact format into a 256 bit int.
arith_uint256& arith_uint256::SetCompact(uint32_t nCompact, bool* pfNegative, bool* pfOverflow)
{
    int nSize = nCompact >> 24;
    uint32_t nWord = nCompact & 0x007fffff;
    if (nSize <= 3) {
        nWord >>= 8 * (3 - nSize);
        *this = nWord;
    } else {
        *this = nWord;
        *this <<= 8 * (nSize - 3);
    }
    if (pfNegative)
        *pfNegative = nWord != 0 && (nCompact & 0x00800000) != 0;
    if (pfOverflow)
        *pfOverflow = nWord != 0 && ((nSize > 34) ||
                                     (nWord > 0xff && nSize > 33) ||
                                     (nWord > 0xffff && nSize > 32));
    return *this;
}

The first 8 bits here are the exponent. The next bit is a sign bit, with 1 being negative. The next 23 bits are the mantissa.
So, 0x00800000 is equal to 0x00000000.

41364: <p>The <a href="https://en.bitcoin.it/wiki/Difficulty" rel="nofollow noreferrer">bitcoin wiki</a> describes difficulty target representation as follows:</p>
<blockquote>
<p>How is difficulty stored in blocks? Each block stores a packed
representation (called &quot;Bits&quot;) for its actual hexadecimal target. The
target can be derived from it via a predefined formula. For example,
if the packed target in the block is 0x1b0404cb, the hexadecimal
target is</p>
<p>0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000</p>
<p>Note that the 0x0404cb value is a signed value in this format. The
largest legal value for this field is 0x7fffff. To make a larger value
you must shift it down one full byte. Also 0x008000 is the smallest
positive valid value.</p>
</blockquote>
<p>Why <code>0x008000</code> is the smallest positive valid value?</p>
 2306: <p>To explain that, let's look at the code that unpacks the compact format into a 256 bit int.</p>

<pre><code>arith_uint256&amp; arith_uint256::SetCompact(uint32_t nCompact, bool* pfNegative, bool* pfOverflow)
{
    int nSize = nCompact &gt;&gt; 24;
    uint32_t nWord = nCompact &amp; 0x007fffff;
    if (nSize &lt;= 3) {
        nWord &gt;&gt;= 8 * (3 - nSize);
        *this = nWord;
    } else {
        *this = nWord;
        *this &lt;&lt;= 8 * (nSize - 3);
    }
    if (pfNegative)
        *pfNegative = nWord != 0 &amp;&amp; (nCompact &amp; 0x00800000) != 0;
    if (pfOverflow)
        *pfOverflow = nWord != 0 &amp;&amp; ((nSize &gt; 34) ||
                                     (nWord &gt; 0xff &amp;&amp; nSize &gt; 33) ||
                                     (nWord &gt; 0xffff &amp;&amp; nSize &gt; 32));
    return *this;
}
</code></pre>

<p>The first 8 bits here are the exponent. The next bit is a sign bit, with 1 being negative. The next 23 bits are the mantissa.</p>

<p>So, <code>0x00800000</code> is equal to <code>0x00000000</code>.</p>
