double Stats::mean() const {
    DEBUG_SINVARIANT(checkInvariants());
    if (number == 0) {
	return 0.0;
    } else {
	return double(sum)/double(number);
    }
};

/* implicit */ AliasIdSet::AliasIdSet(uint32_t id) {
  if (id <= BitsetMax) {
    m_bits = Empty | (1ull << id);
  } else {
    m_bits = id;
  }
  assertx(checkInvariants());
}

void PackedArray::OnSetEvalScalar(ArrayData* ad) {
  assert(checkInvariants(ad));
  auto ptr = packedData(ad);
  auto const stop = ptr + ad->m_packedCap;
  for (; ptr != stop; ++ptr) {
    tvAsVariant(ptr).setEvalScalar();
  }
}

int main(void){

  WDTCTL = WDTPW | WDTHOLD;  // Stop watchdog timer
  PM5CTL0 &= ~LOCKLPM5;
  initializeHardware();
  reboots++;
  DINO_RESTORE_CHECK();

  DINO_TASK_BOUNDARY(START_TASK,NULL);
  if( finished == 0xBEEE ){
#if defined(WISP5)
    PJOUT |= BIT6;
#elif defined(BREADBOARD)
    P4OUT |= BIT4;
#endif
    while( 1 ){ }
  }

  if( inErrorState == 0xBEEE ){

    abortWithError();

  }

  initializeNVData();
  

  while( numSamples < (NUM_ITERS * SAMPLES_PER_ITER) ){

    int r;
    for(r = 0; r < SAMPLES_PER_ITER; r++){

      DINO_TASK_BOUNDARY(SAMPLE_TASK,NULL);
      unsigned samp = getOneSample();
      DINO_TASK_BOUNDARY(BIN_TASK,NULL);
      addToBin(samp);
      numSamples++;

    }

    DINO_TASK_BOUNDARY(SORT_TASK,NULL);
    sortBinsByFrequency();

    DINO_TASK_BOUNDARY(CHECK_TASK,NULL);
    checkInvariants();

  }

  finished = 0xBEEE;
#if defined(WISP5)
  PJOUT |= BIT6;
#elif defined(BREADBOARD)
  P4OUT |= BIT4;
#endif
  while( 1 ){ }

}

VectorEpetra<T>::VectorEpetra ( Epetra_FEVector const * v )
    :
    super( v->Map().NumGlobalElements(), v->Map().NumMyElements() ),
    M_emap( v->Map() ),
    M_vec( *v )
{
    this->init( M_emap, true );
    checkInvariants();
}

void APCHandle::deleteShared() {
  assert(checkInvariants());
  switch (m_kind) {
    case APCKind::Uninit:
    case APCKind::Null:
    case APCKind::Bool:
      return;
    case APCKind::Int:
    case APCKind::Double:
    case APCKind::StaticString:
    case APCKind::StaticArray:
    case APCKind::StaticVec:
    case APCKind::StaticDict:
    case APCKind::StaticKeyset:
      delete APCTypedValue::fromHandle(this);
      return;

    case APCKind::SharedString:
    case APCKind::SerializedArray:
    case APCKind::SerializedVec:
    case APCKind::SerializedDict:
    case APCKind::SerializedKeyset:
    case APCKind::SerializedObject:
      APCString::Delete(APCString::fromHandle(this));
      return;

    case APCKind::SharedPackedArray:
    case APCKind::SharedArray:
    case APCKind::SharedVec:
    case APCKind::SharedDict:
    case APCKind::SharedKeyset:
      APCArray::Delete(this);
      return;

    case APCKind::SharedObject:
      APCObject::Delete(this);
      return;

    case APCKind::SharedCollection:
      APCCollection::Delete(this);
      return;

    case APCKind::UncountedArray:
    case APCKind::UncountedVec:
    case APCKind::UncountedDict:
    case APCKind::UncountedKeyset:
    case APCKind::UncountedString:
      assert(false);
      return;
  }
  not_reached();
}

AliasClass AliasClass::unionData(rep newBits, AliasClass a, AliasClass b) {
  assertx(a.m_stag == b.m_stag);
  switch (a.m_stag) {
  case STag::None:
    break;
  case STag::Frame:
  case STag::Prop:
  case STag::ElemI:
  case STag::ElemS:
  case STag::MIState:
  case STag::Ref:
    assertx(!a.equivData(b));
    break;

  case STag::Stack:
    {
      auto const stkA = a.m_stack;
      auto const stkB = b.m_stack;

      // If two AStack have different bases, we can't union them any better
      // than AStackAny, since we don't know where they are relative to each
      // other.  We know two AStacks with different FramePtr bases can't alias,
      // but that doesn't help us represent a union of them.
      if (stkA.base != stkB.base) return AliasClass{newBits};

      // Make a stack range big enough to contain both of them.
      auto const highest = std::max(stkA.offset, stkB.offset);
      auto const lowest = std::min(lowest_offset(stkA), lowest_offset(stkB));
      auto const newStack = AStack {
        stkA.base,
        highest,
        highest - lowest
      };
      auto ret = AliasClass{newBits};
      new (&ret.m_stack) AStack(newStack);
      ret.m_stag = STag::Stack;
      assertx(ret.checkInvariants());
      assertx(a <= ret && b <= ret);
      return ret;
    }
  }

  return AliasClass{newBits};
}

AliasIdSet AliasIdSet::operator|=(const AliasIdSet rhs) {
  if (*this == rhs || rhs.empty()) return *this;
  if (empty()) {
    m_bits = rhs.m_bits;
    return *this;
  }

  if (isBigInteger() || rhs.isBigInteger()) {
    // Result contains a big integer, as well as one other integer, so we
    // must use bitset mode.
    setUpperRange();
  }

  if (rhs.isBitset()) {
    // Both are bitsets.
    m_bits |= rhs.m_bits;
  }

  assertx(checkInvariants());
  return *this;
}

bool KisZoomAndPanTest::checkZoomWithWheel(ZoomAndPanTester &t, const QPoint &widgetPoint, qreal zoomCoeff, bool limitedZoom)
{
    QPoint oldOffset = t.coordinatesConverter()->documentOffset();
    QPointF oldPrefCenter = t.canvasController()->preferredCenter();
    qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
    QSize oldDocumentSize = t.canvasController()->documentSize();

    t.canvasController()->zoomRelativeToPoint(widgetPoint, zoomCoeff);

    QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();

    return checkInvariants(oldOffset + widgetPoint,
                           oldOffset,
                           oldPrefCenter,
                           oldZoom,
                           t.coordinatesConverter()->documentOffset(),
                           t.canvasController()->preferredCenter(),
                           limitedZoom ? oldZoom : zoomCoeff * oldZoom,
                           newTopLeft,
                           oldDocumentSize);
}

MixedArray* StructArray::ToMixedCopy(const StructArray* old) {
  auto const oldSize = old->size();
  auto const ad      = ToMixedHeader(oldSize + 1);
  auto const srcData = old->data();
  auto shape         = old->shape();

  memset(ad->hashTab(), static_cast<uint8_t>(MixedArray::Empty),
    sizeof(int32_t) * ad->hashSize());

  for (auto i = 0; i < oldSize; ++i) {
    auto key = const_cast<StringData*>(shape->keyForOffset(i));
    auto& e = ad->addKeyAndGetElem(key);
    tvDupFlattenVars(&srcData[i], &e.data, old);
  }

  ad->m_pos = old->m_pos;
  assert(ad->checkInvariants());
  assert(!ad->isFull());
  assert(ad->hasExactlyOneRef());
  return ad;
}