void search()
  {
    if (searched)
      return;
    searched = true;

    Node *start_node = new (node_pool.malloc()) Node(domain.get_start_state(),
                                                     0,
                                                     0);
    domain.compute_heuristic(*start_node);
    goal = idastar_search(start_node);
  }

void *VarCommand::operator new(size_t aSize)
{
	return varcommandpool.malloc();
}

void *PickupGrantUpdate::operator new(size_t aSize)
{
	return killpool.malloc();
}

void *Weapon::operator new(size_t aSize)
{
	return pool.malloc();
}

  BoundedResult
  cost_bounded_search(Node *start_node,
                      const Cost bound)
  {
    if (start_node->get_state() == domain.get_goal_state()) {
      BoundedResult res(start_node);
      assert(res.is_goal());
      return res;
    }

    std::vector<Node *> succs;
    domain.compute_successors(*start_node, succs, node_pool);

    num_expanded += 1;
    num_generated += succs.size();


#ifdef OUTPUT_SEARCH_PROGRESS
      if (get_num_expanded() % 1000000 == 0) {
        std::cerr << "progress update:" << std::endl;
        std::cerr << get_num_expanded() << " total nodes expanded" << std::endl
                  << get_num_generated() << " total nodes generated" << std::endl;
      }
#endif


    boost::optional<Cost> new_cutoff;
    
    for (unsigned i = 0; i < succs.size(); i += 1) {
      Node *succ = succs[i];

#ifdef IDA_STAR_CYCLE_CHECKING
      if (start_node->is_descendent_of(succ)) {
        node_pool.free(succ);
        continue;
      }
#endif      

      domain.compute_heuristic(*start_node, *succ);

      if (succ->get_f() <= bound) {
        BoundedResult res = cost_bounded_search(succ, bound);
        if (res.is_goal()) {
          assert(!res.is_cutoff());
          assert(!res.is_failure());
          return res;
        }
        else if (res.is_cutoff()) {
          assert(!res.is_goal());
          assert(!res.is_failure());

          if (new_cutoff)
            new_cutoff = std::min(*new_cutoff, res.get_cutoff());
          else
            new_cutoff = res.get_cutoff();
        }
      }
      else {
        if (new_cutoff)
          new_cutoff = std::min(*new_cutoff, succ->get_f());
        else
          new_cutoff = succ->get_f();
      }

      node_pool.free(succ);
    } /* end for */

    if (new_cutoff) {
      BoundedResult res(*new_cutoff);
      assert(res.is_cutoff());
      assert(!res.is_goal());
      assert(!res.is_failure());
      return res;
    }
    else {
      // std::cerr << "returning failure!" << std::endl;
      BoundedResult res;
      assert(res.is_failure());
      assert(!res.is_cutoff());
      assert(!res.is_failure());
      return res;
    }
  }

void Collidable::operator delete(void *aPtr)
{
	pool.free(aPtr);
}

void VarInteger::operator delete(void *aPtr)
{
	varintegerpool.free(aPtr);
}

void *Spawner::operator new(size_t aSize)
{
	return pool.malloc();
}

void Spawner::operator delete(void *aPtr)
{
	pool.free(aPtr);
}

void *Collidable::operator new(size_t aSize)
{
	return pool.malloc();
}

void Weapon::operator delete(void *aPtr)
{
	pool.free(aPtr);
}

void Pickup::operator delete(void *aPtr)
{
	pool.free(aPtr);
}

void SimpleParticle::operator delete(void* block)
{
	particlePool.free(block);
}

		void destroy(){
			if(Ptr!=NULL)Pool.destroy(Ptr);
			Ptr=NULL;
		}

		~shared_array_memory(){Pool.destroy(Ptr);}

void* SimpleParticle::operator new(size_t count)
{
	assert(count <= sizeof(SimpleParticle));
	return particlePool.malloc();
}