oy, you just said nothing. it's a pseudo premine because it was annoinced on a virtually empty forum, if it was announced here then when the following gre, moved to the other forum that would make sense. Essentially those who were in the know got to premine this crapcoin.


int64 static GetBlockValue(int nHeight, int64 nFees)
{
int64 nSubsidy = 2 * COIN;
   
    if(nHeight == 2) 
    {
        nSubsidy = 20000 * COIN;
    }
   
    nSubsidy >>= (nHeight / 1004000); // Approx 500 thousand blocks per year

    return nSubsidy + nFees;
}

static const int64 nTargetTimespan = 5 * 120; // Cryptobits: 10mnute retarget days
static const int64 nTargetSpacing = 120; // Cryptobits: 2 minute blocks
static const int64 nInterval = nTargetTimespan / nTargetSpacing;

// Thanks: Balthazar for suggesting the following fix
// https://bitcointalk.org/index.php?topic=182430.msg1904506#msg1904506
static const int64 nReTargetHistoryFact = 4; // look at 4 times the retarget
                                             // interval into the block history

//
// minimum amount of work that could possibly be required nTime after
// minimum work required was nBase
//
unsigned int ComputeMinWork(unsigned int nBase, int64 nTime)
{
    // Testnet has min-difficulty blocks
    // after nTargetSpacing*2 time between blocks:
    if (fTestNet && nTime > nTargetSpacing*2)
        return bnProofOfWorkLimit.GetCompact();

    CBigNum bnResult;
    bnResult.SetCompact(nBase);
    while (nTime > 0 && bnResult < bnProofOfWorkLimit)
    {
        // Maximum 400% adjustment...
        bnResult *= 4;
        // ... in best-case exactly 4-times-normal target time
        nTime -= nTargetTimespan*4;
    }
    if (bnResult > bnProofOfWorkLimit)
        bnResult = bnProofOfWorkLimit;
    return bnResult.GetCompact();
}

unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlock *pblock)
{
    unsigned int nProofOfWorkLimit = bnProofOfWorkLimit.GetCompact();

    // Genesis block
    if (pindexLast == NULL)
        return nProofOfWorkLimit;

    // Only change once per interval
    if ((pindexLast->nHeight+1) % nInterval != 0)
    {
        // Special difficulty rule for testnet:
        if (fTestNet)
        {
            // If the new block's timestamp is more than 2* 10 minutes
            // then allow mining of a min-difficulty block.
            if (pblock->nTime > pindexLast->nTime + nTargetSpacing*2)
                return nProofOfWorkLimit;
            else
            {
                // Return the last non-special-min-difficulty-rules-block
                const CBlockIndex* pindex = pindexLast;
                while (pindex->pprev && pindex->nHeight % nInterval != 0 && pindex->nBits == nProofOfWorkLimit)
                    pindex = pindex->pprev;
                return pindex->nBits;
            }
        }

        return pindexLast->nBits;
    }

    // Litecoin: This fixes an issue where a 51% attack can change difficulty at will.
    // Go back the full period unless it's the first retarget after genesis. Code courtesy of Art Forz
    int blockstogoback = nInterval-1;
    if ((pindexLast->nHeight+1) != nInterval)
        blockstogoback = nInterval;
    if (pindexLast->nHeight > COINFIX1_BLOCK) {
        blockstogoback = nReTargetHistoryFact * nInterval;
    }

    // Go back by what we want to be nReTargetHistoryFact*nInterval blocks
    const CBlockIndex* pindexFirst = pindexLast;
    for (int i = 0; pindexFirst && i < blockstogoback; i++)
        pindexFirst = pindexFirst->pprev;
    assert(pindexFirst);

    // Limit adjustment step
    int64 nActualTimespan = 0;
    if (pindexLast->nHeight > COINFIX1_BLOCK)
        // obtain average actual timespan
        nActualTimespan = (pindexLast->GetBlockTime() - pindexFirst->GetBlockTime())/nReTargetHistoryFact;
    else
        nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
    printf("  nActualTimespan = %"PRI64d"  before bounds\n", nActualTimespan);
    if (nActualTimespan < nTargetTimespan/4)
        nActualTimespan = nTargetTimespan/4;
    if (nActualTimespan > nTargetTimespan*4)
        nActualTimespan = nTargetTimespan*4;

    // Retarget
    CBigNum bnNew;
    bnNew.SetCompact(pindexLast->nBits);
    bnNew *= nActualTimespan;
    bnNew /= nTargetTimespan;

    if (bnNew > bnProofOfWorkLimit)
        bnNew = bnProofOfWorkLimit;

    /// debug print
    printf("GetNextWorkRequired RETARGET\n");
    printf("nTargetTimespan = %"PRI64d"    nActualTimespan = %"PRI64d"\n", nTargetTimespan, nActualTimespan);
    printf("Before: %08x  %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
    printf("After:  %08x  %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());

    return bnNew.GetCompact();
}


this coin is dead if 3 people with at least a 20mh each farm point at it for more than an hour.

Where are the updated windows files?

The link on the original first-post is to an older source than the one I have?

The link I had (I assume burried in one of the non-first posts), gave me a compiled version with 7/9/2013 "modified" dates. The link on the first page gives files that are "modified" on 6/18/2013... thus, older than what I have.

Tell your coder to check his computers time, if he is compiling with an older date than reality, or update the original link on the first post so we don't have to dig to find a program that works. Unless your target is just a minority of poor coders using free OS's, and not the majority of actual people with money using Windows. (Just some food for thought. Not insulting coders, or people not willing to pay for an OS. They have their reasons, I am sure. But they are NOT going to be the primary funding of a coin. If there was anything you should have learned from BTC, it is that internal support of a poor coder leaves you trading pennies, not dollars, for years, and poor structure with "making your program available", essentially kills coins. Just look at mincoin, chncoin, ezcoin, sexcoin, hypercoin, luckycoin, powercoin and anoncoin... You don't want to follow in footsteps that lead you to an open grave.)

why no ann here? pseudo premine

 stbgefltc is working on main code during his free time, please RESPECTFULLY request anything you would like. I am currently looking into getting us on a different exchange and the bank. It's a far chance, but it would change not only NRB but the face of crypto if people could start doing ordinary banking ops with it. Due to location i will not be introducing direct fiat withdrawals in that country, but it will be available at ATMs. Getting Visa to accept us is dependent on American interests so we have already begun talking to the guys who made the first BTC ATM.

There is a nation that has said if we support BTC in our bank, they will let us run parallel to normal eco line as an experiment. Our only squabble with them is that they would like the bank to set guaranteed exchange rates for fiat in their country. I am uncomfortable with this since it puts the bank in for serious losses if BTC tanks.

Release is in 24 hours