static void cwt(const vector<type>& intensities, double& fwhm, vector<double>& result) {
if (intensities.empty()) {
//printf("Empty spectrum no chance !");
//exit(0);
LOG(FATAL) << "Empty spectrum no chance !";
exit(EXIT_FAILURE);
}
//make a copy of size power of 2
vector<double> ints(intensities.begin(), intensities.end());
makePowerOf2(ints);
//double scale = MAGIC * fwhm;
mz_uint N = ints.size();
cwtlib::WTransform *wt;
try {
cwtlib::Signal s( N, &ints[0] );
cwtlib::LinearRangeFunctor scales( fwhm, 3 * fwhm, 2 * fwhm); //perform only at one scale ? ->to test
wt = cwtlib::CWTalgorithm::cwtft(s, scales, cwtlib::MexicanHat(), "Youpi");
} catch(exception& e) {
//printf("%s\n", e.what());
LOG(ERROR) << e.what();
}
//fill result
//result.reserve( intensities.size() );
for (mz_uint i = 0, l=intensities.size(); i < l; ++i) {
result.push_back(wt->re(0, i));
}
delete wt;
}
void ShapeFile::SubsetN_( // select nshapes
int nshapes, // in: number of shapes to select
int seed, // in: if 0 use first nshapes,
// else rand subset of nshapes
const char* sregex) // in: regex string (used only for err msgs)
{
CheckNshapes(nshapes, nshapes_, sregex, shapepath_);
if (seed && nshapes > 1)
{
vec_int ints(nshapes_);
RandInts(ints, seed);
ints.resize(nshapes);
sort(ints.begin(), ints.end());
for (int i = 0; i < nshapes; i++)
{
const int j = ints[i];
shapes_[i] = shapes_[j];
bases_[i] = bases_[j];
bits_[i] = bits_[j];
}
}
nshapes_ = nshapes;
shapes_.resize(nshapes);
bases_.resize(nshapes);
bits_.resize(nshapes);
}
static jcharArray formatResult(JNIEnv* env, const UnicodeString& s, FieldPositionIterator* fpi, jobject javaFieldPositionIterator) {
static jmethodID gFPI_setData = env->GetMethodID(JniConstants::fieldPositionIteratorClass, "setData", "([I)V");
if (fpi != NULL) {
std::vector<int32_t> data;
FieldPosition fp;
while (fpi->next(fp)) {
data.push_back(fp.getField());
data.push_back(fp.getBeginIndex());
data.push_back(fp.getEndIndex());
}
jintArray javaData = NULL;
if (!data.empty()) {
javaData = env->NewIntArray(data.size());
if (javaData == NULL) {
return NULL;
}
ScopedIntArrayRW ints(env, javaData);
if (ints.get() == NULL) {
return NULL;
}
memcpy(ints.get(), &data[0], data.size() * sizeof(int32_t));
}
env->CallVoidMethod(javaFieldPositionIterator, gFPI_setData, javaData);
}
jcharArray result = env->NewCharArray(s.length());
if (result != NULL) {
env->SetCharArrayRegion(result, 0, s.length(), s.getBuffer());
}
return result;
}
native_handle_t *JNativeHandle::MakeCppNativeHandle(
JNIEnv *env, jobject jHandle, EphemeralStorage *storage) {
if (jHandle == nullptr) { return nullptr; }
if (!env->IsInstanceOf(jHandle, gNativeHandleFields.clazz)) {
jniThrowException(env, "java/lang/ClassCastException",
"jHandle must be an instance of NativeHandle.");
return nullptr;
}
ScopedLocalRef<jintArray> fds(env, (jintArray) env->CallObjectMethod(
jHandle, gNativeHandleFields.getFdsID));
ScopedLocalRef<jintArray> ints(env, (jintArray) env->CallObjectMethod(
jHandle, gNativeHandleFields.getIntsID));
const int numFds = (int) env->GetArrayLength(fds.get());
const int numInts = (int) env->GetArrayLength(ints.get());
native_handle_t *handle = (storage == nullptr)
? native_handle_create(numFds, numInts)
: storage->allocTemporaryNativeHandle(numFds, numInts);
if (handle != nullptr) {
env->GetIntArrayRegion(fds.get(), 0, numFds, &(handle->data[0]));
env->GetIntArrayRegion(ints.get(), 0, numInts, &(handle->data[numFds]));
} else {
jniThrowException(env, "java/lang/OutOfMemoryError",
"Failed to allocate memory for native_handle_t.");
}
return handle;
}
static jcharArray formatResult(JNIEnv* env, const UnicodeString &str,
FieldPositionIterator* fpi, jobject fpIter) {
jclass fieldPositionIteratorClass = env->FindClass(
"com/ibm/icu4jni/text/NativeDecimalFormat$FieldPositionIterator");
static jmethodID gFPI_setData = env->GetMethodID(
fieldPositionIteratorClass, "setData", "([I)V");
if (fpi != NULL) {
int len = fpi->getData(NULL, 0);
jintArray data = NULL;
if (len) {
data = env->NewIntArray(len);
ScopedIntArrayRW ints(env, data);
if (ints.get() == NULL) {
return NULL;
}
fpi->getData(ints.get(), len);
}
env->CallVoidMethod(fpIter, gFPI_setData, data);
}
jcharArray result = env->NewCharArray(str.length());
if (result != NULL) {
// by jshwang
// env->SetCharArrayRegion(result, 0, str.length(), str.getBuffer());
env->SetCharArrayRegion(result, 0, str.length(),
(jchar *) str.getBuffer());
}
return result;
}
int SDLFrontend::renderFilledPolygon (int *vx, int *vy, int n, const Color& color)
{
if (!vx || !vy || n < 3)
return -1;
ScopedArrayPtr<int> ints(new int[n]);
int miny = vy[0];
int maxy = vy[0];
for (int i = 1; i < n; i++) {
if (vy[i] > maxy)
maxy = vy[i];
if (vy[i] < miny)
miny = vy[i];
}
int result = 0;
for (int y = miny; y <= maxy; y++) {
int num_ints = 0;
for (int i = 0; i < n; i++) {
int ind1, ind2;
if (i == 0) {
ind1 = n - 1;
ind2 = 0;
} else {
ind1 = i - 1;
ind2 = i;
}
int x1;
int x2;
int y1 = vy[ind1];
int y2 = vy[ind2];
if (y1 < y2) {
x1 = vx[ind1];
x2 = vx[ind2];
} else if (y1 > y2) {
y2 = vy[ind1];
y1 = vy[ind2];
x2 = vx[ind1];
x1 = vx[ind2];
} else {
continue;
}
if ((y >= y1 && y < y2) || (y == maxy && y <= y2 && y > y1)) {
ints[num_ints++] = ((y - y1) * (x2 - x1) / (y2 - y1)) + x1;
}
}
SDL_qsort(ints, num_ints, sizeof(int), sortRenderFilledPolygon);
for (int i = 0; i < num_ints; i += 2) {
const int start = ints[i];
const int end = ints[i + 1];
result |= SDL_RenderDrawLine(_renderer, start, y, end, y);
}
}
return result;
}
sexpr ints(int low, int up)
{
if (low > up) {
return(nil);
} else {
return(small_cons(small_cons(INT_TO_SEXPR(low), nil), ints(low+1, up)));
}
}
// ============================================================================
StatusCode Tuples::TupleObj::column ( const std::string& name ,
const int value )
{
if ( invalid() ) { return InvalidTuple ; }
Int* item = ints( name ) ;
if ( !item ) { return InvalidColumn ; }
*item = value ;
return StatusCode::SUCCESS ;
}
std::vector<size_t> splitAsInt(const std::string &s, char delim) {
std::vector<std::string> tokens = split(s, delim);
std::vector<size_t> ints(tokens.size());
for (size_t i=0; i<ints.size(); ++i)
ints[i] = ::atoi(tokens[i].c_str());
return ints;
}
void * tiny_reverse_test(void * arg)
# endif
{
int i;
for (i = 0; i < 5; ++i) {
check_ints(reverse(reverse(ints(1,10))), 1, 10);
}
return 0;
}
void * tiny_reverse_test(void * arg)
# endif
{
int i;
for (i = 0; i < 5; ++i) {
check_ints(reverse(reverse(ints(1, TINY_REVERSE_UPPER_VALUE))),
1, TINY_REVERSE_UPPER_VALUE);
}
return 0;
}
QArray<int> ODateBookAccessBackend_XML::nonRepeats()const {
QArray<int> ints( m_raw.count() );
uint i = 0;
QMap<int, OEvent>::ConstIterator it;
for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
ints[i] = it.key();
i++;
}
return ints;
}
int main(int argc, const char * argv[]) {
Array<int> ints(3);
ints[0] = 10;
ints[1] = 2;
ints[2] = 15;
int min = minimum(ints, less); // в min должно попасть число 2
std::cout << "min = " << min << "\n";
int max = minimum(ints, Greater()); // в max должно попасть число 15
std::cout << "max = " << max << "\n";
return 0;
}
void set_range(iterator& i, iterator& end) {
boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
ints->push_back(0);
ints->push_back(1);
ints->push_back(2);
ints->push_back(3);
ints->push_back(4);
ints->push_back(5);
i = iterator(ints->begin(),ints);
end = iterator(ints->end(),ints);
}
jobject JNativeHandle::MakeJavaNativeHandleObj(
JNIEnv *env, const native_handle_t *handle) {
if (handle == nullptr) { return nullptr; }
const int numFds = handle->numFds;
ScopedLocalRef<jintArray> fds(env, env->NewIntArray(numFds));
env->SetIntArrayRegion(fds.get(), 0, numFds, &(handle->data[0]));
const int numInts = handle->numInts;
ScopedLocalRef<jintArray> ints(env, env->NewIntArray(numInts));
env->SetIntArrayRegion(ints.get(), 0, numInts, &(handle->data[numFds]));
return env->NewObject(gNativeHandleFields.clazz,
gNativeHandleFields.constructID, fds.get(), ints.get(), false /*own*/);
}
QArray<int> ODateBookAccessBackend_VCal::allRecords()const {
QArray<int> ints( m_raw.count()+ m_rep.count() );
uint i = 0;
QMap<int, OPimEvent>::ConstIterator it;
for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
ints[i] = it.key();
i++;
}
for ( it = m_rep.begin(); it != m_rep.end(); ++it ) {
ints[i] = it.key();
i++;
}
return ints;
}
int main()
{
Vector<int> ints(5);
for(int i = 0; i < 5; i++)
ints[i] = i;
// EXAMPLE #1
auto doubles = ints.map([] (int i) { return i * 2; });
// EXAMPLE #2
auto words = doubles.map(int_to_str);
for(int i = 0; i < 5; i++)
std::cout << words[i] << std::endl;
return 0;
}
int main() {
typedef boost::shared_ptr< std::vector<int> > ints_t;
{
ints_t ints(new std::vector<int>());
ints->push_back(0);
ints->push_back(1);
ints->push_back(2);
ints->push_back(3);
ints->push_back(4);
ints->push_back(5);
print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
boost::make_shared_container_iterator(ints->end(),ints));
}
return 0;
}
void QGCodeViewer::onOpenGCode(QString filename)
{
QFile fin(filename);
QFile fout(gcodefile);
if (fin.open(QFile::ReadOnly | QFile::Text) && ( fout.open( QIODevice::ReadWrite | QIODevice::Truncate | QIODevice::Text) ) )
{
QTextStream ints(&fin);
QTextStream outts(&fout);
while(!ints.atEnd())
outts << ints.readLine() << "\n";
fin.close();
fout.close();
clear();
emit setRS274(rs274);
emit setToolTable(tooltable);
emit setGcodeFile(openFile = gcodefile);
emit interpret();
}
}
static jintArray NativeBN_bn2litEndInts(JNIEnv* env, jclass, BIGNUM* a) {
if (!oneValidHandle(env, a)) return NULL;
bn_check_top(a);
int len = a->top;
if (len == 0) {
return NULL;
}
jintArray result = env->NewIntArray(len);
if (result == NULL) {
return NULL;
}
ScopedIntArrayRW ints(env, result);
if (ints.get() == NULL) {
return NULL;
}
BN_ULONG* ulongs = reinterpret_cast<BN_ULONG*>(ints.get());
if (ulongs == NULL) {
return NULL;
}
int i = len; do { i--; ulongs[i] = a->d[i]; } while (i > 0);
return result;
}
int main(int argc, char ** argv)
{
if (argc <= 1) {
throw std::runtime_error("NOT ENOUGH ARGS: ./sim FILE");
}
using ri = LogInTact::sample::real_interval;
using res = LogInTact::sim::linear_sim<3, SIM_CHUNK_SIZE>;
using int_rv = std::array<ri, 3>;
using int_rm = std::array<ri, 9>;
std::cout << sizeof(res) << " bytes" << std::endl;
LogInTact::sample::sim_param_intervals<3> ints(
/* s_0 */
int_rv{ri{0, 1}, ri{0, 1}, ri{0, 1}},
/* D */
int_rv{ri{0, 1}, ri{0, 1}, ri{0, 1}},
/* W */
int_rm{ri{0, 1}, ri{0, 1}, ri{0, 1}, ri{0, 1}, ri{0, 1}, ri{0, 1},
ri{0, 1}, ri{0, 1}, ri{0, 1}});
/* TODO: read intervals from file, get output file from argv */
size_t num_chunks = 0;
signal(SIGINT, catch_sigint);
const size_t steps_to_equil = 50;
constexpr size_t granularity = 500;
std::cerr << SIM_CHUNK_SIZE << ',' << SIM_CHUNK_NUM << std::endl;
try {
LogInTact::io::run_sim_async<3, granularity, SIM_CHUNK_SIZE>(
3, 0, steps_to_equil, ints, argv[1], [&]() {
++num_chunks;
return num_chunks < SIM_CHUNK_NUM or terminate.load();
});
} catch (LogInTact::io::io_exception & e) {
std::cerr << "WTF: " << e.what() << std::endl;
exit(EXIT_FAILURE);
}
return 0;
}
int testMonad()
{
Susp<int> x = mjoin(fmap(ints(1, 4), sum));
Susp<int> y = mbind(ints(1, 4), sum);
return y.get();
}
int LuaGenerator::parameter(lua_State *L, int index)
{
const char *typedname = luaL_checkstring(L, index);
core::ParamType type;
if (type.fromstring(typedname, NULL) == false)
return luaL_error(L, "TypeError: Cannot parse parameter type.");
bool istable = lua_istable(L, index + 1);
int totalElements = type.type.numelements() * type.type.aggregate;
if (totalElements > 1 && !istable)
return luaL_error(L, "TypeError: Cannot pass single value to an array/vector/matrix type.");
switch (type.type.basetype)
{
case OIIO::TypeDesc::FLOAT:
{
if (istable)
{
int n = luaL_getn(L, index + 1);
std::vector<float> floats(n);
for (int i = 0; i < n; ++i)
{
lua_rawgeti(L, index + 1, i + 1);
floats[i] = luaL_checknumber(L, -1);
lua_pop(L, 1);
}
api_->parameter(typedname, tokenize(floats));
}
else
{
api_->parameter(typedname, luaL_checknumber(L, index + 1));
}
break;
}
case OIIO::TypeDesc::INT:
{
if (istable)
{
int n = luaL_getn(L, index + 1);
std::vector<int> ints(n);
for (int i = 0; i < n; ++i)
{
lua_rawgeti(L, index + 1, i + 1);
ints[i] = luaL_checkint(L, -1);
lua_pop(L, 1);
}
api_->parameter(typedname, tokenize(ints));
}
else
{
api_->parameter(typedname, luaL_checkint(L, index + 1));
}
break;
}
case OIIO::TypeDesc::STRING:
{
if (istable)
{
int n = luaL_getn(L, index + 1);
std::vector<const char*> strs(n);
for (int i = 0; i < n; ++i)
{
lua_rawgeti(L, index + 1, i + 1);
strs[i] = luaL_checkstring(L, -1);
lua_pop(L, 1);
}
api_->parameter(typedname, tokenize(strs));
}
else
{
api_->parameter(typedname, tokenize(luaL_checkstring(L, index + 1)));
}
break;
}
default:
return luaL_error(L, "TypeError: Unsupported base type.");
}
return 0;
}
struct saucy *
saucy_alloc(int n)
{
struct saucy *s = (saucy*) malloc(sizeof(struct saucy));
if (s == NULL) return NULL;
s->ninduce = ints(n);
s->sinduce = ints(n);
s->indmark = bits(n);
s->left.cfront = zeros(n);
s->left.clen = ints(n);
s->right.cfront = zeros(n);
s->right.clen = ints(n);
s->stuff = bits(n+1);
s->bucket = ints(n+2);
s->count = ints(n+1);
s->ccount = zeros(n);
s->clist = ints(n);
s->nextnon = ints(n+1) + 1;
s->prevnon = ints(n+1);
s->anctar = ints(n);
s->start = ints(n);
s->gamma = ints(n);
s->junk = ints(n);
s->theta = ints(n);
s->thsize = ints(n);
s->left.lab = ints(n);
s->left.unlab = ints(n);
s->right.lab = ints(n);
s->right.unlab = ints(n);
s->splitwho = ints(n);
s->splitfrom = ints(n);
s->splitlev = ints(n+1);
s->unsupp = ints(n);
s->conncnts = zeros(n);
s->diffmark = bits(n);
s->diffs = ints(n);
s->difflev = ints(n);
s->undifflev = ints(n);
s->specmin = ints(n);
s->thnext = ints(n);
s->thprev = ints(n);
s->threp = ints(n);
s->thfront = ints(n);
s->pairs = ints(n);
s->unpairs = ints(n);
s->diffnons = ints(n);
s->undiffnons = ints(n);
if (s->ninduce && s->sinduce && s->left.cfront && s->left.clen
&& s->right.cfront && s->right.clen
&& s->stuff && s->bucket && s->count && s->ccount
&& s->clist && s->nextnon-1 && s->prevnon
&& s->start && s->gamma && s->theta && s->left.unlab
&& s->right.lab && s->right.unlab
&& s->left.lab && s->splitwho && s->junk
&& s->splitfrom && s->splitlev && s->thsize
&& s->unsupp && s->conncnts && s->anctar
&& s->diffmark && s->diffs && s->indmark
&& s->thnext && s->thprev && s->threp && s->thfront
&& s->pairs && s->unpairs && s->diffnons && s->undiffnons
&& s->difflev && s->undifflev && s->specmin)
{
return s;
}
else {
saucy_free(s);
return NULL;
}
}
fastuidraw::gl::varying_list&
fastuidraw::gl::varying_list::
add_int_varying(const char *pname)
{
return set_int_varying(ints().size(), pname);
}
void SnapshotLoader::load(ConcurrentTableSharedStore& s) {
// This could share code with apc_load_impl_compressed, but that function
// should go away together with the shared object format.
{
std::vector<KeyValuePair> ints(read32());
for (auto& item : ints) {
item.key = readString().begin();
s.constructPrime(read64(), item);
}
s.prime(ints);
}
{
std::vector<KeyValuePair> chars(read32());
for (auto& item : chars) {
item.key = readString().begin();
switch (static_cast<SnapshotBuilder::CharBasedType>(read<char>())) {
case SnapshotBuilder::kSnapFalse:
s.constructPrime(false, item);
break;
case SnapshotBuilder::kSnapTrue:
s.constructPrime(true, item);
break;
case SnapshotBuilder::kSnapNull:
s.constructPrime(uninit_null(), item);
break;
default:
assert(false);
break;
}
}
s.prime(chars);
}
auto numStringBased = read32();
CHECK(numStringBased == SnapshotBuilder::kNumStringBased);
for (int i = 0; i < numStringBased; ++i) {
auto type = static_cast<SnapshotBuilder::StringBasedType>(i);
std::vector<KeyValuePair> items(read32());
for (auto& item : items) {
item.key = readString().begin();
auto data = readString();
String value(data.begin(), data.size(), CopyString);
switch (type) {
case SnapshotBuilder::kSnapString:
s.constructPrime(value, item, false);
break;
case SnapshotBuilder::kSnapObject:
s.constructPrime(value, item, true);
break;
case SnapshotBuilder::kSnapThrift: {
Variant success;
Variant v = HHVM_FN(fb_unserialize)(value, ref(success));
if (same(success, false)) {
throw Exception("bad apc archive, fb_unserialize failed");
}
s.constructPrime(v, item);
break;
}
case SnapshotBuilder::kSnapOther: {
Variant v = unserialize_from_string(value);
if (same(v, false)) {
throw Exception("bad apc archive, unserialize_from_string failed");
}
s.constructPrime(v, item);
break;
}
default:
assert(false);
break;
}
}
s.prime(items);
}
{
const char* disk = m_begin + header().diskOffset;
std::vector<KeyValuePair> items(read32());
for (auto& item : items) {
item.key = readString().begin();
item.sSize = read32();
item.sAddr = const_cast<char*>(disk);
disk += abs(item.sSize) + 1; // \0
}
assert(disk == m_begin + m_size);
s.prime(items);
}
assert(m_cur == m_begin + header().diskOffset);
// Keys have been copied, so don't need that part any more.
madvise(const_cast<char*>(m_begin), header().diskOffset, MADV_DONTNEED);
}
/*
* Repeatedly reverse lists built out of very different sized cons cells.
* Check that we didn't lose anything.
*/
void *GC_CALLBACK reverse_test_inner(void *data)
{
int i;
sexpr b;
sexpr c;
sexpr d;
sexpr e;
sexpr *f, *g, *h;
if (data == 0) {
/* This stack frame is not guaranteed to be scanned. */
return GC_call_with_gc_active(reverse_test_inner, (void*)(word)1);
}
# if /*defined(MSWIN32) ||*/ defined(MACOS)
/* Win32S only allows 128K stacks */
# define BIG 1000
# elif defined(PCR)
/* PCR default stack is 100K. Stack frames are up to 120 bytes. */
# define BIG 700
# elif defined(MSWINCE) || defined(RTEMS)
/* WinCE only allows 64K stacks */
# define BIG 500
# elif defined(OSF1)
/* OSF has limited stack space by default, and large frames. */
# define BIG 200
# elif defined(__MACH__) && defined(__ppc64__)
# define BIG 2500
# else
# define BIG 4500
# endif
A.dummy = 17;
a = ints(1, 49);
b = ints(1, 50);
c = ints(1, BIG);
d = uncollectable_ints(1, 100);
e = uncollectable_ints(1, 1);
/* Check that realloc updates object descriptors correctly */
collectable_count++;
f = (sexpr *)GC_MALLOC(4 * sizeof(sexpr));
realloc_count++;
f = (sexpr *)GC_REALLOC((void *)f, 6 * sizeof(sexpr));
f[5] = ints(1,17);
collectable_count++;
g = (sexpr *)GC_MALLOC(513 * sizeof(sexpr));
realloc_count++;
g = (sexpr *)GC_REALLOC((void *)g, 800 * sizeof(sexpr));
g[799] = ints(1,18);
collectable_count++;
h = (sexpr *)GC_MALLOC(1025 * sizeof(sexpr));
realloc_count++;
h = (sexpr *)GC_REALLOC((void *)h, 2000 * sizeof(sexpr));
# ifdef GC_GCJ_SUPPORT
h[1999] = gcj_ints(1,200);
for (i = 0; i < 51; ++i)
h[1999] = gcj_reverse(h[1999]);
/* Leave it as the reveresed list for now. */
# else
h[1999] = ints(1,200);
# endif
/* Try to force some collections and reuse of small list elements */
for (i = 0; i < 10; i++) {
(void)ints(1, BIG);
}
/* Superficially test interior pointer recognition on stack */
c = (sexpr)((char *)c + sizeof(char *));
d = (sexpr)((char *)d + sizeof(char *));
GC_FREE((void *)e);
check_ints(b,1,50);
check_ints(a,1,49);
for (i = 0; i < 50; i++) {
check_ints(b,1,50);
b = reverse(reverse(b));
}
check_ints(b,1,50);
check_ints(a,1,49);
for (i = 0; i < 60; i++) {
# if defined(GC_PTHREADS) || defined(GC_WIN32_THREADS)
if (i % 10 == 0) fork_a_thread();
# endif
/* This maintains the invariant that a always points to a list of */
/* 49 integers. Thus this is thread safe without locks, */
/* assuming atomic pointer assignments. */
a = reverse(reverse(a));
# if !defined(AT_END) && !defined(THREADS)
/* This is not thread safe, since realloc explicitly deallocates */
if (i & 1) {
a = (sexpr)GC_REALLOC((void *)a, 500);
} else {
a = (sexpr)GC_REALLOC((void *)a, 8200);
}
# endif
}
check_ints(a,1,49);
check_ints(b,1,50);
/* Restore c and d values. */
c = (sexpr)((char *)c - sizeof(char *));
d = (sexpr)((char *)d - sizeof(char *));
check_ints(c,1,BIG);
check_uncollectable_ints(d, 1, 100);
check_ints(f[5], 1,17);
check_ints(g[799], 1,18);
# ifdef GC_GCJ_SUPPORT
h[1999] = gcj_reverse(h[1999]);
# endif
check_ints(h[1999], 1,200);
# ifndef THREADS
a = 0;
# endif
*(volatile void **)&b = 0;
*(volatile void **)&c = 0;
return 0;
}
