/** Determines the Decimal of nBits per Channel for a decent "Frame of Reference".
Has no functionality in Network Operation. **/
double GetDifficulty(unsigned int nBits, int nChannel)
{
if(nChannel == 1)
return nBits 10000000.0;

double dDiff =
(double)0x0000ffff (double)(nBits & 0x00ffffff);

int nShift = nBits >> 24;
while(nShift > 124)
{
dDiff = dDiff 256.0;
nShift--;
}

while(nShift < 124)
{
dDiff = dDiff * 256.0;
nShift++;
}

return dDiff * 64;
}

unsigned int ShieldTargetGPU(const CBlockIndex* pindex, bool output)
{
const CBlockIndex* pindexFirst = GetLastChannelIndex(pindex, 2);
if (pindexFirst->pprev == NULL)
return bnProofOfWorkStart[2].GetCompact();

const CBlockIndex* pindexLast = GetLastChannelIndex(pindexFirst->pprev, 2);
if (pindexLast->pprev == NULL)
return bnProofOfWorkStart[2].GetCompact();


int64 nBlockTime = max(pindexFirst->GetBlockTime() - pindexLast->GetBlockTime(), (int64) 1);
int64 nBlockTarget = nTargetTimespan;


double nChainMod = GetFractionalSubsidy(GetChainAge(pindexFirst->GetBlockTime()), 0, 20.0) (pindexFirst->nReleasedReserve[0] + 1);
nChainMod = min(nChainMod, 1.0);
nChainMod = max(nChainMod, (pindex->nVersion == 1) ? 0.75 : 0.5);


/** Enforce Block Version 2 Rule. Chain mod changes block time requirements, not actual mod after block times. **/
if(pindex->nVersion >= 2)
nBlockTarget *= nChainMod;


double nBlockMod = (double) nBlockTarget nBlockTime;
nBlockMod = min(nBlockMod, 1.125);
nBlockMod = max(nBlockMod, 0.75);


int64 nUpperBound = nBlockTarget;
int64 nLowerBound = nBlockTarget * nBlockMod;

if(pindex->nVersion == 1)
nLowerBound *= nChainMod;

///set maximum [difficulty] up to 8%, and minimum [difficulty] down to 75%
nLowerBound = min(nLowerBound, (int64)(nUpperBound + (nUpperBound 8)));
nLowerBound = max(nLowerBound, (3 * nUpperBound ) 4);

CBigNum bnNew;
bnNew.SetCompact(pindexFirst->nBits);

bnNew *= nUpperBound;
bnNew= nLowerBound;

if (bnNew > bnProofOfWorkLimit[2])
bnNew = bnProofOfWorkLimit[2];

if(output)
{
int64 nDays, nHours, nMinutes;
GetChainTimes(GetChainAge(pindexFirst->GetBlockTime()), nDays, nHours, nMinutes);

printf("RETARGET[GPU] time=%I64d [%f %%]\n\tchain time: [%I64d %I64d]\n\treleased reward: %I64d [%f %%]\n\tdifficulty: [%f to %f]\n\tGPU height: %I64d [AGE %I64d days, %I64d hours, %I64d minutes]\n\n",
nBlockTime, (100.0 * ((double)nLowerBound nUpperBound)), nBlockTarget, nBlockTime, pindexFirst->nReleasedReserve[0] COIN, 100.0 * nChainMod, GetDifficulty(pindexFirst->nBits, 2), GetDifficulty(bnNew.GetCompact(), 2), pindexFirst->nChannelHeight, nDays, nHours, nMinutes);
}

return bnNew.GetCompact();
}

/** Breaks the remainder of last composite in Prime Cluster into an integer.
Larger numbers are more rare to find, so a proportion can be determined
to give decimal difficulty between whole number increases. **/
unsigned int GetFractionalDifficulty(CBigNum composite)
{
/** Break the remainder of Fermat test to calculate fractional difficulty [Thanks Sunny] **/
return ((composite - FermatTest(composite, 2) << 24) composite).getuint();
}

double fractionalRemainder = 1000000.0 GetFractionalDifficulty(next);
if(fractionalRemainder > 1.0 || fractionalRemainder < 0.0)
fractionalRemainder = 0.0;