/*===========================================================================*/
/*   (Llib/thread.scm)                                                       */
/*   Bigloo (4.7a)                                                           */
/*   Inria -- Sophia Antipolis (c)       Thu Feb 19 09:11:58 AM CET 2026     */
/*===========================================================================*/
/* COMPILATION: (/home/serrano/prgm/project/bigloo/4.7a/bin/bigloo -srfi bigloo-unsafe -O3 -fcfa-arithmetic -q -lib-dir /home/serrano/prgm/project/bigloo/4.7a/lib/bigloo/4.7a +rm -mklib -cc gcc -fsharing -q -no-hello -unsafe -safee -O4 -stdc -c Llib/thread.scm -indent -o objs/obj_u/Llib/thread.c) */
/* GC selection */
#define THE_GC BOEHM_GC

/* unsafe mode */
#define BIGLOO_UNSAFE 1

/* traces mode */
#define BIGLOO_TRACE 0

/* standard Bigloo include */
#include <bigloo.h>

#ifdef __cplusplus
extern "C"
{
#endif
#ifndef BGL_MODULE_TYPE_DEFINITIONS
#define BGL_MODULE_TYPE_DEFINITIONS
#ifndef BGL___THREAD_TYPE_DEFINITIONS
#define BGL___THREAD_TYPE_DEFINITIONS

/* object type definitions */
	typedef struct BgL_nothreadzd2backendzd2_bgl
	{
		header_t header;
		obj_t widening;
		obj_t BgL_namez00;
	}                            *BgL_nothreadzd2backendzd2_bglt;

	typedef struct BgL_threadzd2backendzd2_bgl
	{
		header_t header;
		obj_t widening;
		obj_t BgL_namez00;
	}                          *BgL_threadzd2backendzd2_bglt;

	typedef struct BgL_threadz00_bgl
	{
		header_t header;
		obj_t widening;
		obj_t BgL_namez00;
	}                *BgL_threadz00_bglt;

	typedef struct BgL_nothreadz00_bgl
	{
		header_t header;
		obj_t widening;
		obj_t BgL_namez00;
		obj_t BgL_bodyz00;
		obj_t BgL_z52specificz52;
		obj_t BgL_z52cleanupz52;
		obj_t BgL_endzd2resultzd2;
		obj_t BgL_endzd2exceptionzd2;
		obj_t BgL_z52namez52;
	}                  *BgL_nothreadz00_bglt;


#endif													// BGL___THREAD_TYPE_DEFINITIONS
#endif													// BGL_MODULE_TYPE_DEFINITIONS

	static obj_t BGl_z62threadzd2killz12zd2nothrea1242z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62threadzd2specificzd2noth1244z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2namezd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2parameterzd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62z52userzd2currentzd2thread1225z30zz__threadz00(obj_t,
		obj_t);
	extern obj_t bgl_make_nil_condvar(void);
	static obj_t BGl_z52currentzd2threadz80zz__threadz00(void);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2cleanupzd2zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62threadzd2namezd2setz12zd2not1254za2zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(BgL_threadz00_bglt, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_tbzd2condvarzd2initializa7ez12zb5zz__threadz00
		(BgL_threadzd2backendzd2_bglt, obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2setz121214z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62z52userzd2threadzd2yieldz121231z22zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2joinz12za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl__makezd2mutexzd2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62z52userzd2currentzd2threadz30zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00(obj_t,
		obj_t);
	extern obj_t BGl_classzd2constructorzd2zz__objectz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_conditionzd2variablezd2nilz00zz__threadz00(void);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2lockz12zc0zz__threadz00(obj_t, long);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2specificzd2zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62zc3z04anonymousza31370ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2specificzb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31427ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_requirezd2initializa7ationz75zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_withzd2lockzd2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_za2threadzd2backendsza2zd2zz__threadz00 = BUNSPEC;
	extern obj_t BGl_raisez00zz__errorz00(obj_t);
	extern obj_t bgl_remq_bang(obj_t, obj_t);
	extern obj_t BGl_exitz00zz__errorz00(obj_t);
	static obj_t BGl_z62threadzd2joinz121201za2zz__threadz00(obj_t, obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2cleanupzd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	extern void bgl_sleep(long);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2joinz12zc0zz__threadz00(BgL_threadz00_bglt, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_z52userzd2currentzd2threadz52zz__threadz00(BgL_threadz00_bglt);
	extern obj_t BGl_typezd2errorzd2zz__errorz00(obj_t, obj_t, obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_modulezd2initializa7ationz75zz__threadz00(long,
		char *);
	extern obj_t BGl_modulezd2initializa7ationz75zz__objectz00(long, char *);
	extern obj_t BGl_modulezd2initializa7ationz75zz__errorz00(long, char *);
	BGL_EXPORTED_DECL bool_t
		BGl_conditionzd2variablezd2broadcastz12z12zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00(obj_t, obj_t,
		obj_t);
	extern obj_t BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_makezd2mutexzd2zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_threadzd2sleepz12zc0zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_defaultzd2threadzd2backendz00zz__threadz00(void);
	extern obj_t BGl_za2classesza2z00zz__objectz00;
	extern obj_t BGl_callzd2virtualzd2getterz00zz__objectz00(BgL_objectz00_bglt,
		int);
	extern obj_t bgl_nanoseconds_to_date(BGL_LONGLONG_T);
	static obj_t BGl_z62threadzd2namezb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2parameterzb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31534ze3ze5zz__threadz00(obj_t);
	extern obj_t BGl_registerzd2genericz12zc0zz__objectz00(obj_t, obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2startzd2joinabl1199z62zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2statezd2zz__threadz00(obj_t);
	static obj_t BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_conditionzd2variablezd2namez00zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_currentzd2threadzd2zz__threadz00(void);
	static obj_t
		BGl_threadzd2startz12zd2nothre1234ze70zf5zz__threadz00(BgL_nothreadz00_bglt,
		obj_t);
	static obj_t BGl_nothreadzd2backendzd2zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2startzd2joinablez12z70zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_toplevelzd2initzd2zz__threadz00(void);
	static obj_t BGl_z62conditionzd2variablezd2namez62zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62zc3z04anonymousza31551ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31470ze3ze5zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_withzd2timedzd2lockz00zz__threadz00(obj_t, int,
		obj_t);
	extern obj_t bgl_make_nil_mutex(void);
	BGL_EXPORTED_DECL obj_t
		BGl_tbzd2mutexzd2initializa7ez12zb5zz__threadz00
		(BgL_threadzd2backendzd2_bglt, obj_t);
	static obj_t BGl_z62withzd2timedzd2lockz62zz__threadz00(obj_t, obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2nothr1248z62zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_currentzd2threadzd2backendz00zz__threadz00(void);
	static BgL_nothreadzd2backendzd2_bglt
		BGl_za2nothreadzd2backendza2zd2zz__threadz00;
	static obj_t BGl_z62threadzd2specificzd2setz121210z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static BgL_nothreadz00_bglt BGl_z62lambda1422z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t, obj_t, obj_t, obj_t, obj_t);
	static obj_t
		BGl_zc3z04exitza31569ze3ze70z60zz__threadz00(BgL_nothreadz00_bglt, obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31382ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31463ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62currentzd2dynamiczd2envz62zz__threadz00(obj_t);
	static BgL_nothreadz00_bglt BGl_z62lambda1425z62zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31439ze3ze5zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2startz12zc0zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_z62threadzd2name1216zb0zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_assqz00zz__r4_pairs_and_lists_6_3z00(obj_t, obj_t);
	static obj_t BGl_cnstzd2initzd2zz__threadz00(void);
	static obj_t BGl_symbol2301z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2221z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_genericzd2initzd2zz__threadz00(void);
	static obj_t BGl_symbol2306z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2namezd2zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2currentzd2thread1179z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2228z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62mutexzd2nilzb0zz__threadz00(obj_t);
	extern obj_t BGl_registerzd2classz12zc0zz__objectz00(obj_t, obj_t, obj_t,
		long, obj_t, obj_t, obj_t, obj_t, obj_t, obj_t, obj_t);
	static obj_t BGl_importedzd2moduleszd2initz00zz__threadz00(void);
	static BgL_threadz00_bglt BGl_z62tbzd2makezd2threadz62zz__threadz00(obj_t,
		obj_t, obj_t, obj_t);
	static obj_t BGl__makezd2spinlockzd2zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2unlockz12zc0zz__threadz00(obj_t);
	static obj_t BGl_gczd2rootszd2initz00zz__threadz00(void);
	static obj_t BGl_z62lambda1431z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1432z62zz__threadz00(obj_t, obj_t, obj_t);
	extern obj_t BGl_makezd2classzd2fieldz00zz__objectz00(obj_t, obj_t, obj_t,
		bool_t, bool_t, obj_t, obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31456ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31448ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31359ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62lambda1437z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1438z62zz__threadz00(obj_t, obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_currentzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt);
	static obj_t BGl_z62threadzd2killz12za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62mutexzf3z91zz__threadz00(obj_t, obj_t);
	static obj_t BGl_objectzd2initzd2zz__threadz00(void);
	static obj_t BGl_z62threadzd2specific1207zb0zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_2za2za2zz__r4_numbers_6_5z00(obj_t, obj_t);
	static obj_t BGl_symbol2311z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_threadzd2yieldz12zc0zz__threadz00(void);
	static obj_t BGl_symbol2231z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62conditionzd2variablezf3z43zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62defaultzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_symbol2315z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2startz12zd2nothre1234z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62conditionzd2variablezd2broadcastz12z70zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl__makezd2threadzd2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2sleepz12za2zz__threadz00(obj_t, obj_t);
	extern double BGl_numberzd2ze3flonumz31zz__r4_numbers_6_5z00(obj_t);
	extern obj_t bgl_bignum_mul(obj_t, obj_t);
	static obj_t BGl_z62threadzd2specificzd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	extern obj_t BGl_za2inheritancesza2z00zz__objectz00;
	extern obj_t BGl_z62exceptionz62zz__objectz00;
	static obj_t BGl_z62lambda1446z62zz__threadz00(obj_t, obj_t);
	static BgL_threadzd2backendzd2_bglt BGl_z62lambda1366z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62lambda1447z62zz__threadz00(obj_t, obj_t, obj_t);
	extern obj_t BGl_objectz00zz__objectz00;
	static BgL_threadzd2backendzd2_bglt BGl_z62lambda1368z62zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_getzd2threadzd2backendz00zz__threadz00(obj_t);
	extern obj_t BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(obj_t, obj_t);
	static obj_t BGl_symbol2241z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2killz121205za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62dynamiczd2envzf3z43zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62objectzd2writezd2thread1192z62zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62mutexzd2namezb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31482ze3ze5zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2killz12zc0zz__threadz00(BgL_threadz00_bglt, int);
	static obj_t BGl_z62zc3z04anonymousza31393ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1454z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62lambda1374z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1455z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1375z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62threadzd2specificzd2setz121246z70zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2initializa7ez12z67zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62threadzd2cleanup1212zb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2250z00zz__threadz00 = BUNSPEC;
	extern obj_t BGl_displayza2za2zz__r4_output_6_10_3z00(obj_t);
	static obj_t BGl_symbol2252z00zz__threadz00 = BUNSPEC;
	extern obj_t BGl_classzd2namezd2zz__objectz00(obj_t);
	static obj_t BGl_symbol2256z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2specificzd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_symbol2257z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2terminatez12zd2no1240z70zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2joinz12zd2nothrea1238z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static BgL_threadz00_bglt BGl_z62lambda1380z62zz__threadz00(obj_t);
	static obj_t BGl_z62lambda1461z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31394ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62lambda1462z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62threadzd2terminatez12za2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2startz12za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1387z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1468z62zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL bool_t BGl_dynamiczd2envzf3z21zz__threadz00(obj_t);
	extern BGL_LONGLONG_T bgl_current_nanoseconds(void);
	static obj_t BGl_z62lambda1388z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1469z62zz__threadz00(obj_t, obj_t, obj_t);
	extern bool_t BGl_isazf3zf3zz__objectz00(obj_t, obj_t);
	extern obj_t bstring_to_symbol(obj_t);
	static obj_t BGl_z62getzd2threadzd2backendz62zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2namezd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_symbol2262z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2nilzd2zz__threadz00(void);
	BGL_EXPORTED_DECL BgL_threadz00_bglt BGl_makezd2threadzd2zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2startzd2joinablez12z12zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_symbol2266z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL bool_t
		BGl_conditionzd2variablezd2signalz12z12zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31412ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2startz121197za2zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31404ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2namezd2setz121218z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2cleanupzb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62mutexzd2unlockz12za2zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_gensymz00zz__r4_symbols_6_4z00(obj_t);
	static obj_t BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00(obj_t,
		obj_t, obj_t);
	static BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1476z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2initializa7ez12z05zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2270z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_methodzd2initzd2zz__threadz00(void);
	extern obj_t BGl_bigloozd2typezd2errorz00zz__errorz00(obj_t, obj_t, obj_t);
	extern obj_t BGl_genericzd2addzd2methodz12z12zz__objectz00(obj_t, obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62threadzd2yieldz12za2zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_threadzd2namezd2zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_symbol2357z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2initializa7ez121195z05zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_makezd2spinlockzd2zz__threadz00(obj_t);
	extern obj_t BGl_objectzd2writezd2zz__objectz00(BgL_objectz00_bglt, obj_t);
	static obj_t BGl_z62conditionzd2variablezd2nilz62zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2currentzd2threadz62zz__threadz00(obj_t, obj_t);
	static BgL_nothreadzd2backendzd2_bglt
		BGl_z62lambda1480z62zz__threadz00(obj_t);
	BGL_EXPORTED_DEF obj_t BGl_nothreadz00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_threadzd2parameterzd2setz12z12zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_symbol2360z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2280z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2cleanupzd2setz12zd21250za2zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_symbol2362z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2363z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2282z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2364z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2365z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL BgL_threadz00_bglt
		BGl_tbzd2makezd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt, obj_t,
		obj_t);
	static obj_t BGl_symbol2366z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62mutexzd2statezb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2367z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2286z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2368z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2369z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62objectzd2printzd2thread1194z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62conditionzd2variablezd2signalz12z70zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31414ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31406ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	extern long bgl_date_to_seconds(obj_t);
	static BgL_threadz00_bglt
		BGl_z62tbzd2makezd2threadzd2nothr1182zb0zz__threadz00(obj_t, obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL bool_t BGl_mutexzf3zf3zz__threadz00(obj_t);
	static obj_t BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31575ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31389ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_za2nothreadzd2currentza2zd2zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62tbzd2makezd2thread1176z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t);
	static obj_t BGl_symbol2370z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2371z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2372z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2291z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2373z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62defaultzd2threadzd2backendz62zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_makezd2conditionzd2variablez00zz__threadz00(obj_t);
	static obj_t BGl_symbol2374z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_threadzd2parameterzd2zz__threadz00(obj_t);
	static obj_t BGl_symbol2375z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2296z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_currentzd2dynamiczd2envz00zz__threadz00(void);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2terminatez12zc0zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_za2mutexzd2nilza2zd2zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62withzd2lockzb0zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl__conditionzd2variablezd2waitz12z12zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL bool_t
		BGl_conditionzd2variablezd2waitz12z12zz__threadz00(obj_t, obj_t, long);
	static obj_t BGl_za2conditionzd2variablezd2nilza2z00zz__threadz00 = BUNSPEC;
	static obj_t BGl__makezd2conditionzd2variablez00zz__threadz00(obj_t, obj_t);
	extern obj_t bgl_long_to_bignum(long);
	static obj_t BGl__mutexzd2lockz12zc0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62objectzd2displayzd2threa1190z62zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62currentzd2threadzb0zz__threadz00(obj_t);
	BGL_EXPORTED_DEF obj_t BGl_threadz00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62zc3z04anonymousza31399ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL bool_t BGl_conditionzd2variablezf3z21zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_defaultzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt);
	static obj_t BGl_z62threadzd2terminatez121203za2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62currentzd2threadzd2backendz62zz__threadz00(obj_t);
	extern obj_t BGl_errorz00zz__errorz00(obj_t, obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_tbzd2currentzd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt);
	BGL_EXPORTED_DEF obj_t BGl_threadzd2backendzd2zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2startzd2joinabl1236z62zz__threadz00(obj_t,
		obj_t);
	extern obj_t BGl_callzd2virtualzd2setterz00zz__objectz00(BgL_objectz00_bglt,
		int, obj_t);
	static obj_t BGl_z62threadzd2namezd2nothread1252z62zz__threadz00(obj_t,
		obj_t);
	static obj_t *__cnst;


	   
		 
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_makezd2conditionzd2variablezd2envzd2zz__threadz00,
		BgL_bgl__makeza7d2conditio2430za7, opt_generic_entry,
		BGl__makezd2conditionzd2variablez00zz__threadz00, BFALSE, -1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_dynamiczd2envzf3zd2envzf3zz__threadz00,
		BgL_bgl_za762dynamicza7d2env2431z00,
		BGl_z62dynamiczd2envzf3z43zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2waitz12zd2envzc0zz__threadz00,
		BgL_bgl__conditionza7d2var2432za7, opt_generic_entry,
		BGl__conditionzd2variablezd2waitz12z12zz__threadz00, BFALSE, -1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2signalz12zd2envzc0zz__threadz00,
		BgL_bgl_za762conditionza7d2v2433z00,
		BGl_z62conditionzd2variablezd2signalz12z70zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2212z00zz__threadz00,
		BgL_bgl_string2212za700za7za7_2434za7, "nothread", 8);
	      BGL_DEFINE_STRING(BGl_string2213z00zz__threadz00,
		BgL_bgl_string2213za700za7za7_2435za7,
		"/tmp/bigloo/runtime/Llib/thread.scm", 35);
	      BGL_DEFINE_STRING(BGl_string2214z00zz__threadz00,
		BgL_bgl_string2214za700za7za7_2436za7, "&current-thread-backend-set!", 28);
	      BGL_DEFINE_STRING(BGl_string2215z00zz__threadz00,
		BgL_bgl_string2215za700za7za7_2437za7, "thread-backend", 14);
	      BGL_DEFINE_STRING(BGl_string2216z00zz__threadz00,
		BgL_bgl_string2216za700za7za7_2438za7, "&default-thread-backend-set!", 28);
	      BGL_DEFINE_STRING(BGl_string2217z00zz__threadz00,
		BgL_bgl_string2217za700za7za7_2439za7, "&get-thread-backend", 19);
	      BGL_DEFINE_STRING(BGl_string2218z00zz__threadz00,
		BgL_bgl_string2218za700za7za7_2440za7, "bstring", 7);
	      BGL_DEFINE_STRING(BGl_string2219z00zz__threadz00,
		BgL_bgl_string2219za700za7za7_2441za7, "_make-thread", 12);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
		BgL_bgl_za762currentza7d2thr2442z00,
		BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezf3zd2envzf3zz__threadz00,
		BgL_bgl_za762conditionza7d2v2443z00,
		BGl_z62conditionzd2variablezf3z43zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_defaultzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
		BgL_bgl_za762defaultza7d2thr2444z00,
		BGl_z62defaultzd2threadzd2backendzd2setz12za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2namezd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2name2445z00, BGl_z62threadzd2namezb0zz__threadz00,
		0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2220z00zz__threadz00,
		BgL_bgl_string2220za700za7za7_2446za7, "vector", 6);
	      BGL_DEFINE_STRING(BGl_string2302z00zz__threadz00,
		BgL_bgl_string2302za700za7za7_2447za7, "end-exception", 13);
	      BGL_DEFINE_STRING(BGl_string2222z00zz__threadz00,
		BgL_bgl_string2222za700za7za7_2448za7, "thread", 6);
	      BGL_DEFINE_STRING(BGl_string2223z00zz__threadz00,
		BgL_bgl_string2223za700za7za7_2449za7, "procedure", 9);
	      BGL_DEFINE_STRING(BGl_string2224z00zz__threadz00,
		BgL_bgl_string2224za700za7za7_2450za7, "&thread-parameter", 17);
	      BGL_DEFINE_STRING(BGl_string2225z00zz__threadz00,
		BgL_bgl_string2225za700za7za7_2451za7, "symbol", 6);
	      BGL_DEFINE_STRING(BGl_string2307z00zz__threadz00,
		BgL_bgl_string2307za700za7za7_2452za7, "%name", 5);
	      BGL_DEFINE_STRING(BGl_string2226z00zz__threadz00,
		BgL_bgl_string2226za700za7za7_2453za7, "&thread-parameter-set!", 22);
	      BGL_DEFINE_STRING(BGl_string2227z00zz__threadz00,
		BgL_bgl_string2227za700za7za7_2454za7, "_make-mutex", 11);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2spinlockzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2spinlock2455za7, opt_generic_entry,
		BGl__makezd2spinlockzd2zz__threadz00, BFALSE, -1);
	      BGL_DEFINE_STRING(BGl_string2229z00zz__threadz00,
		BgL_bgl_string2229za700za7za7_2456za7, "mutex", 5);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2300z00zz__threadz00,
		BgL_bgl_za762lambda1461za7622457z00, BGl_z62lambda1461z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2303z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2458za7,
		BGl_z62zc3z04anonymousza31470ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2459za7,
		BGl_z62tbzd2makezd2threadz62zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2304z00zz__threadz00,
		BgL_bgl_za762lambda1469za7622460z00, BGl_z62lambda1469z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2305z00zz__threadz00,
		BgL_bgl_za762lambda1468za7622461z00, BGl_z62lambda1468z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2230z00zz__threadz00,
		BgL_bgl_string2230za700za7za7_2462za7, "_make-spinlock", 14);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2namezd2envzd2zz__threadz00,
		BgL_bgl_za762conditionza7d2v2463z00,
		BGl_z62conditionzd2variablezd2namez62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_currentzd2threadzd2envz00zz__threadz00,
		BgL_bgl_za762currentza7d2thr2464z00,
		BGl_z62currentzd2threadzb0zz__threadz00, 0L, BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2232z00zz__threadz00,
		BgL_bgl_string2232za700za7za7_2465za7, "spinlock", 8);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2308z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2466za7,
		BGl_z62zc3z04anonymousza31427ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2233z00zz__threadz00,
		BgL_bgl_string2233za700za7za7_2467za7, "&mutex-name", 11);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2309z00zz__threadz00,
		BgL_bgl_za762lambda1425za7622468z00, BGl_z62lambda1425z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2234z00zz__threadz00,
		BgL_bgl_string2234za700za7za7_2469za7, "_mutex-lock!", 12);
	      BGL_DEFINE_STRING(BGl_string2316z00zz__threadz00,
		BgL_bgl_string2316za700za7za7_2470za7, "nothread-backend", 16);
	      BGL_DEFINE_STRING(BGl_string2235z00zz__threadz00,
		BgL_bgl_string2235za700za7za7_2471za7, "bint", 4);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2cleanupzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2472z00,
		BGl_z62threadzd2cleanupzb0zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2317z00zz__threadz00,
		BgL_bgl_string2317za700za7za7_2473za7, "", 0);
	      BGL_DEFINE_STRING(BGl_string2236z00zz__threadz00,
		BgL_bgl_string2236za700za7za7_2474za7, "&mutex-unlock!", 14);
	      BGL_DEFINE_STRING(BGl_string2318z00zz__threadz00,
		BgL_bgl_string2318za700za7za7_2475za7, "bigloo", 6);
	      BGL_DEFINE_STRING(BGl_string2237z00zz__threadz00,
		BgL_bgl_string2237za700za7za7_2476za7, "&mutex-state", 12);
	      BGL_DEFINE_STRING(BGl_string2238z00zz__threadz00,
		BgL_bgl_string2238za700za7za7_2477za7, "&with-lock", 10);
	      BGL_DEFINE_STRING(BGl_string2239z00zz__threadz00,
		BgL_bgl_string2239za700za7za7_2478za7, "&with-timed-lock", 16);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzf3zd2envz21zz__threadz00,
		BgL_bgl_za762mutexza7f3za791za7za72479za7, BGl_z62mutexzf3z91zz__threadz00,
		0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2310z00zz__threadz00,
		BgL_bgl_za762lambda1422za7622480z00, BGl_z62lambda1422z62zz__threadz00, 0L,
		BUNSPEC, 7);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2312z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2481za7,
		BGl_z62zc3z04anonymousza31482ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2parameterzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2para2482z00,
		BGl_z62threadzd2parameterzb0zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2400z00zz__threadz00,
		BgL_bgl_string2400za700za7za7_2483za7, "object-display", 14);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2313z00zz__threadz00,
		BgL_bgl_za762lambda1480za7622484z00, BGl_z62lambda1480z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2320z00zz__threadz00,
		BgL_bgl_string2320za700za7za7_2485za7, "tb-make-thread1176", 18);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2314z00zz__threadz00,
		BgL_bgl_za762lambda1476za7622486z00, BGl_z62lambda1476z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2402z00zz__threadz00,
		BgL_bgl_string2402za700za7za7_2487za7, "object-write", 12);
	      BGL_DEFINE_STRING(BGl_string2240z00zz__threadz00,
		BgL_bgl_string2240za700za7za7_2488za7, "_make-condition-variable", 24);
	      BGL_DEFINE_STRING(BGl_string2322z00zz__threadz00,
		BgL_bgl_string2322za700za7za7_2489za7, "tb-current-thread1179", 21);
	      BGL_DEFINE_STRING(BGl_string2404z00zz__threadz00,
		BgL_bgl_string2404za700za7za7_2490za7, "object-print", 12);
	      BGL_DEFINE_STRING(BGl_string2242z00zz__threadz00,
		BgL_bgl_string2242za700za7za7_2491za7, "condition-variable", 18);
	      BGL_DEFINE_STRING(BGl_string2324z00zz__threadz00,
		BgL_bgl_string2324za700za7za7_2492za7, "tb-mutex-initialize!1185", 24);
	      BGL_DEFINE_STRING(BGl_string2243z00zz__threadz00,
		BgL_bgl_string2243za700za7za7_2493za7, "&condition-variable-name", 24);
	      BGL_DEFINE_STRING(BGl_string2406z00zz__threadz00,
		BgL_bgl_string2406za700za7za7_2494za7, "thread-start!", 13);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2319z00zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2495za7,
		BGl_z62tbzd2makezd2thread1176z62zz__threadz00, 0L, BUNSPEC, 3);
	      BGL_DEFINE_STRING(BGl_string2244z00zz__threadz00,
		BgL_bgl_string2244za700za7za7_2496za7, "condvar", 7);
	      BGL_DEFINE_STRING(BGl_string2326z00zz__threadz00,
		BgL_bgl_string2326za700za7za7_2497za7, "tb-condvar-initializ1187", 24);
	      BGL_DEFINE_STRING(BGl_string2245z00zz__threadz00,
		BgL_bgl_string2245za700za7za7_2498za7, "_condition-variable-wait!", 25);
	      BGL_DEFINE_STRING(BGl_string2408z00zz__threadz00,
		BgL_bgl_string2408za700za7za7_2499za7, "thread-start-joinable!", 22);
	      BGL_DEFINE_STRING(BGl_string2246z00zz__threadz00,
		BgL_bgl_string2246za700za7za7_2500za7, "&condition-variable-signal!", 27);
	      BGL_DEFINE_STRING(BGl_string2328z00zz__threadz00,
		BgL_bgl_string2328za700za7za7_2501za7, "thread-initialize!1195", 22);
	      BGL_DEFINE_STRING(BGl_string2247z00zz__threadz00,
		BgL_bgl_string2247za700za7za7_2502za7, "&condition-variable-broadcast!",
		30);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2startz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2star2503z00, va_generic_entry,
		BGl_z62threadzd2startz12za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2nilzd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2nilza7b2504za7, BGl_z62mutexzd2nilzb0zz__threadz00,
		0L, BUNSPEC, 0);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2threadzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2threadza7d2505z00, opt_generic_entry,
		BGl__makezd2threadzd2zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2401z00zz__threadz00,
		BgL_bgl_za762objectza7d2writ2506z00, va_generic_entry,
		BGl_z62objectzd2writezd2thread1192z62zz__threadz00, BUNSPEC, -2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2321z00zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72507za7,
		BGl_z62tbzd2currentzd2thread1179z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2403z00zz__threadz00,
		BgL_bgl_za762objectza7d2prin2508z00,
		BGl_z62objectzd2printzd2thread1194z62zz__threadz00, 0L, BUNSPEC, 3);
	      BGL_DEFINE_STRING(BGl_string2410z00zz__threadz00,
		BgL_bgl_string2410za700za7za7_2509za7, "thread-join!", 12);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2323z00zz__threadz00,
		BgL_bgl_za762tbza7d2mutexza7d22510za7,
		BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2405z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2511z00, va_generic_entry,
		BGl_z62threadzd2startz12zd2nothre1234z70zz__threadz00, BUNSPEC, -2);
	      BGL_DEFINE_STRING(BGl_string2330z00zz__threadz00,
		BgL_bgl_string2330za700za7za7_2512za7, "thread-start!1197", 17);
	      BGL_DEFINE_STRING(BGl_string2412z00zz__threadz00,
		BgL_bgl_string2412za700za7za7_2513za7, "thread-terminate!", 17);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2325z00zz__threadz00,
		BgL_bgl_za762tbza7d2condvarza72514za7,
		BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2407z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2515z00,
		BGl_z62threadzd2startzd2joinabl1236z62zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2332z00zz__threadz00,
		BgL_bgl_string2332za700za7za7_2516za7, "thread-start-joinabl1199", 24);
	      BGL_DEFINE_STRING(BGl_string2251z00zz__threadz00,
		BgL_bgl_string2251za700za7za7_2517za7, "name", 4);
	      BGL_DEFINE_STRING(BGl_string2414z00zz__threadz00,
		BgL_bgl_string2414za700za7za7_2518za7, "thread-kill!", 12);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2327z00zz__threadz00,
		BgL_bgl_za762threadza7d2init2519z00,
		BGl_z62threadzd2initializa7ez121195z05zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2409z00zz__threadz00,
		BgL_bgl_za762threadza7d2join2520z00, va_generic_entry,
		BGl_z62threadzd2joinz12zd2nothrea1238z70zz__threadz00, BUNSPEC, -2);
	      BGL_DEFINE_STRING(BGl_string2334z00zz__threadz00,
		BgL_bgl_string2334za700za7za7_2521za7, "thread-join!1201", 16);
	      BGL_DEFINE_STRING(BGl_string2416z00zz__threadz00,
		BgL_bgl_string2416za700za7za7_2522za7, "thread-specific", 15);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2329z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2523z00, va_generic_entry,
		BGl_z62threadzd2startz121197za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2248z00zz__threadz00,
		BgL_bgl_za762lambda1375za7622524z00, BGl_z62lambda1375z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2336z00zz__threadz00,
		BgL_bgl_string2336za700za7za7_2525za7, "thread-terminate!1203", 21);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2249z00zz__threadz00,
		BgL_bgl_za762lambda1374za7622526z00, BGl_z62lambda1374z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2418z00zz__threadz00,
		BgL_bgl_string2418za700za7za7_2527za7, "thread-specific-set!", 20);
	      BGL_DEFINE_STRING(BGl_string2338z00zz__threadz00,
		BgL_bgl_string2338za700za7za7_2528za7, "thread-kill!1205", 16);
	      BGL_DEFINE_STRING(BGl_string2258z00zz__threadz00,
		BgL_bgl_string2258za700za7za7_2529za7, "__thread", 8);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
		BgL_bgl_za762za752userza7d2cur2530za7,
		BGl_z62z52userzd2currentzd2threadz30zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2411z00zz__threadz00,
		BgL_bgl_za762threadza7d2term2531z00,
		BGl_z62threadzd2terminatez12zd2no1240z70zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2331z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2532z00,
		BGl_z62threadzd2startzd2joinabl1199z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2413z00zz__threadz00,
		BgL_bgl_za762threadza7d2kill2533z00,
		BGl_z62threadzd2killz12zd2nothrea1242z70zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2420z00zz__threadz00,
		BgL_bgl_string2420za700za7za7_2534za7, "thread-cleanup", 14);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2333z00zz__threadz00,
		BgL_bgl_za762threadza7d2join2535z00, va_generic_entry,
		BGl_z62threadzd2joinz121201za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2415z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2536z00,
		BGl_z62threadzd2specificzd2noth1244z62zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2340z00zz__threadz00,
		BgL_bgl_string2340za700za7za7_2537za7, "thread-specific1207", 19);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2253z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2538za7,
		BGl_z62zc3z04anonymousza31370ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2422z00zz__threadz00,
		BgL_bgl_string2422za700za7za7_2539za7, "thread-cleanup-set!", 19);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2335z00zz__threadz00,
		BgL_bgl_za762threadza7d2term2540z00,
		BGl_z62threadzd2terminatez121203za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2254z00zz__threadz00,
		BgL_bgl_za762lambda1368za7622541z00, BGl_z62lambda1368z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2417z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2542z00,
		BGl_z62threadzd2specificzd2setz121246z70zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2342z00zz__threadz00,
		BgL_bgl_string2342za700za7za7_2543za7, "thread-specific-set!1210", 24);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2255z00zz__threadz00,
		BgL_bgl_za762lambda1366za7622544z00, BGl_z62lambda1366z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2424z00zz__threadz00,
		BgL_bgl_string2424za700za7za7_2545za7, "thread-name", 11);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2337z00zz__threadz00,
		BgL_bgl_za762threadza7d2kill2546z00,
		BGl_z62threadzd2killz121205za2zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2419z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2547z00,
		BGl_z62threadzd2cleanupzd2nothr1248z62zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2344z00zz__threadz00,
		BgL_bgl_string2344za700za7za7_2548za7, "thread-cleanup1212", 18);
	      BGL_DEFINE_STRING(BGl_string2263z00zz__threadz00,
		BgL_bgl_string2263za700za7za7_2549za7, "obj", 3);
	      BGL_DEFINE_STRING(BGl_string2426z00zz__threadz00,
		BgL_bgl_string2426za700za7za7_2550za7, "thread-name-set!", 16);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2339z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2551z00,
		BGl_z62threadzd2specific1207zb0zz__threadz00, 0L, BUNSPEC, 1);
	extern obj_t BGl_objectzd2writezd2envz00zz__objectz00;
	   
		 
		BGL_DEFINE_STRING(BGl_string2427z00zz__threadz00,
		BgL_bgl_string2427za700za7za7_2552za7, ">", 1);
	      BGL_DEFINE_STRING(BGl_string2346z00zz__threadz00,
		BgL_bgl_string2346za700za7za7_2553za7, "thread-cleanup-set!1214", 23);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2259z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2554za7,
		BGl_z62zc3z04anonymousza31389ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2428z00zz__threadz00,
		BgL_bgl_string2428za700za7za7_2555za7, ":", 1);
	      BGL_DEFINE_STRING(BGl_string2429z00zz__threadz00,
		BgL_bgl_string2429za700za7za7_2556za7, "#<", 2);
	      BGL_DEFINE_STRING(BGl_string2348z00zz__threadz00,
		BgL_bgl_string2348za700za7za7_2557za7, "thread-name1216", 15);
	      BGL_DEFINE_STRING(BGl_string2267z00zz__threadz00,
		BgL_bgl_string2267za700za7za7_2558za7, "specific", 8);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2statezd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2state2559z00, BGl_z62mutexzd2statezb0zz__threadz00,
		0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2421z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2560z00,
		BGl_z62threadzd2cleanupzd2setz12zd21250za2zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2341z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2561z00,
		BGl_z62threadzd2specificzd2setz121210z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2260z00zz__threadz00,
		BgL_bgl_za762lambda1388za7622562z00, BGl_z62lambda1388z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2423z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2563z00,
		BGl_z62threadzd2namezd2nothread1252z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2261z00zz__threadz00,
		BgL_bgl_za762lambda1387za7622564z00, BGl_z62lambda1387z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2343z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2565z00,
		BGl_z62threadzd2cleanup1212zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2425z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2566z00,
		BGl_z62threadzd2namezd2setz12zd2not1254za2zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2350z00zz__threadz00,
		BgL_bgl_string2350za700za7za7_2567za7, "thread-name-set!1218", 20);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2345z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2568z00,
		BGl_z62threadzd2cleanupzd2setz121214z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2264z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2569za7,
		BGl_z62zc3z04anonymousza31394ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2352z00zz__threadz00,
		BgL_bgl_string2352za700za7za7_2570za7, "%user-current-thread1225", 24);
	      BGL_DEFINE_STRING(BGl_string2271z00zz__threadz00,
		BgL_bgl_string2271za700za7za7_2571za7, "cleanup", 7);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2265z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2572za7,
		BGl_z62zc3z04anonymousza31393ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2347z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2573z00,
		BGl_z62threadzd2name1216zb0zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2354z00zz__threadz00,
		BgL_bgl_string2354za700za7za7_2574za7, "%user-thread-sleep!1228", 23);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2349z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2575z00,
		BGl_z62threadzd2namezd2setz121218z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2268z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2576za7,
		BGl_z62zc3z04anonymousza31399ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2356z00zz__threadz00,
		BgL_bgl_string2356za700za7za7_2577za7, "%user-thread-yield!1231", 23);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2269z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2578za7,
		BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2358z00zz__threadz00,
		BgL_bgl_string2358za700za7za7_2579za7, "thread-sleep!", 13);
	      BGL_DEFINE_STRING(BGl_string2359z00zz__threadz00,
		BgL_bgl_string2359za700za7za7_2580za7, "date, real, or integer", 22);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
		BgL_bgl_za762threadza7d2init2581z00,
		BGl_z62threadzd2initializa7ez12z05zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762currentza7d2thr2582z00,
		BGl_z62currentzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2351z00zz__threadz00,
		BgL_bgl_za762za752userza7d2cur2583za7,
		BGl_z62z52userzd2currentzd2thread1225z30zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2nilzd2envzd2zz__threadz00,
		BgL_bgl_za762conditionza7d2v2584z00,
		BGl_z62conditionzd2variablezd2nilz62zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2lockz12zd2envz12zz__threadz00,
		BgL_bgl__mutexza7d2lockza7122585z00, opt_generic_entry,
		BGl__mutexzd2lockz12zc0zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2353z00zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2586za7,
		BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2272z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2587za7,
		BGl_z62zc3z04anonymousza31404ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2dynamiczd2envzd2envzd2zz__threadz00,
		BgL_bgl_za762currentza7d2dyn2588z00,
		BGl_z62currentzd2dynamiczd2envz62zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2273z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2589za7,
		BGl_z62zc3z04anonymousza31406ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2361z00zz__threadz00,
		BgL_bgl_string2361za700za7za7_2590za7, "No method for this object", 25);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2355z00zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2591za7,
		BGl_z62z52userzd2threadzd2yieldz121231z22zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2274z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2592za7,
		BGl_z62zc3z04anonymousza31412ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2281z00zz__threadz00,
		BgL_bgl_string2281za700za7za7_2593za7, "body", 4);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2275z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2594za7,
		BGl_z62zc3z04anonymousza31414ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2276z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2595za7,
		BGl_z62zc3z04anonymousza31382ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2term2596z00,
		BGl_z62threadzd2terminatez12za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2277z00zz__threadz00,
		BgL_bgl_za762lambda1380za7622597z00, BGl_z62lambda1380z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2278z00zz__threadz00,
		BgL_bgl_za762lambda1432za7622598z00, BGl_z62lambda1432z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2279z00zz__threadz00,
		BgL_bgl_za762lambda1431za7622599z00, BGl_z62lambda1431z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_withzd2lockzd2envz00zz__threadz00,
		BgL_bgl_za762withza7d2lockza7b2600za7, BGl_z62withzd2lockzb0zz__threadz00,
		0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2287z00zz__threadz00,
		BgL_bgl_string2287za700za7za7_2601za7, "%specific", 9);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2name2602z00,
		BGl_z62threadzd2namezd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2namezd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2nameza72603za7, BGl_z62mutexzd2namezb0zz__threadz00,
		0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2283z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2604za7,
		BGl_z62zc3z04anonymousza31439ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2unlockz12zd2envz12zz__threadz00,
		BgL_bgl_za762mutexza7d2unloc2605z00,
		BGl_z62mutexzd2unlockz12za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2284z00zz__threadz00,
		BgL_bgl_za762lambda1438za7622606z00, BGl_z62lambda1438z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2285z00zz__threadz00,
		BgL_bgl_za762lambda1437za7622607z00, BGl_z62lambda1437z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2292z00zz__threadz00,
		BgL_bgl_string2292za700za7za7_2608za7, "%cleanup", 8);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2288z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2609za7,
		BGl_z62zc3z04anonymousza31448ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2376z00zz__threadz00,
		BgL_bgl_string2376za700za7za7_2610za7, "&tb-make-thread", 15);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2289z00zz__threadz00,
		BgL_bgl_za762lambda1447za7622611z00, BGl_z62lambda1447z62zz__threadz00, 0L,
		BUNSPEC, 2);
	extern obj_t BGl_conszd2envzd2zz__r4_pairs_and_lists_6_3z00;
	   
		 
		BGL_DEFINE_STRING(BGl_string2377z00zz__threadz00,
		BgL_bgl_string2377za700za7za7_2612za7, "&tb-current-thread", 18);
	      BGL_DEFINE_STRING(BGl_string2378z00zz__threadz00,
		BgL_bgl_string2378za700za7za7_2613za7, "&tb-mutex-initialize!", 21);
	      BGL_DEFINE_STRING(BGl_string2297z00zz__threadz00,
		BgL_bgl_string2297za700za7za7_2614za7, "end-result", 10);
	      BGL_DEFINE_STRING(BGl_string2379z00zz__threadz00,
		BgL_bgl_string2379za700za7za7_2615za7, "&tb-condvar-initialize!", 23);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2joinz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2join2616z00, va_generic_entry,
		BGl_z62threadzd2joinz12za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2yieldz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2yiel2617z00,
		BGl_z62threadzd2yieldz12za2zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2mutexzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2mutexza7d22618z00, opt_generic_entry,
		BGl__makezd2mutexzd2zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2290z00zz__threadz00,
		BgL_bgl_za762lambda1446za7622619z00, BGl_z62lambda1446z62zz__threadz00, 0L,
		BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72620za7,
		BGl_z62tbzd2currentzd2threadz62zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2380z00zz__threadz00,
		BgL_bgl_string2380za700za7za7_2621za7, "&thread-initialize!", 19);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2293z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2622za7,
		BGl_z62zc3z04anonymousza31456ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2381z00zz__threadz00,
		BgL_bgl_string2381za700za7za7_2623za7, "&thread-start!", 14);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2294z00zz__threadz00,
		BgL_bgl_za762lambda1455za7622624z00, BGl_z62lambda1455z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2382z00zz__threadz00,
		BgL_bgl_string2382za700za7za7_2625za7, "&thread-start-joinable!", 23);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2295z00zz__threadz00,
		BgL_bgl_za762lambda1454za7622626z00, BGl_z62lambda1454z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2383z00zz__threadz00,
		BgL_bgl_string2383za700za7za7_2627za7, "&thread-join!", 13);
	      BGL_DEFINE_STRING(BGl_string2384z00zz__threadz00,
		BgL_bgl_string2384za700za7za7_2628za7, "&thread-terminate!", 18);
	      BGL_DEFINE_STRING(BGl_string2385z00zz__threadz00,
		BgL_bgl_string2385za700za7za7_2629za7, "&thread-kill!", 13);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2298z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2630za7,
		BGl_z62zc3z04anonymousza31463ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      BGL_DEFINE_STRING(BGl_string2386z00zz__threadz00,
		BgL_bgl_string2386za700za7za7_2631za7, "&thread-specific", 16);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2299z00zz__threadz00,
		BgL_bgl_za762lambda1462za7622632z00, BGl_z62lambda1462z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2387z00zz__threadz00,
		BgL_bgl_string2387za700za7za7_2633za7, "&thread-specific-set!", 21);
	      BGL_DEFINE_STRING(BGl_string2388z00zz__threadz00,
		BgL_bgl_string2388za700za7za7_2634za7, "&thread-cleanup", 15);
	      BGL_DEFINE_STRING(BGl_string2389z00zz__threadz00,
		BgL_bgl_string2389za700za7za7_2635za7, "&thread-cleanup-set!", 20);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_threadzd2parameterzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2para2636z00,
		BGl_z62threadzd2parameterzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2637za7,
		BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00, 0L, BUNSPEC, 1);
	      BGL_DEFINE_STRING(BGl_string2390z00zz__threadz00,
		BgL_bgl_string2390za700za7za7_2638za7, "&thread-name", 12);
	      BGL_DEFINE_STRING(BGl_string2391z00zz__threadz00,
		BgL_bgl_string2391za700za7za7_2639za7, "&thread-name-set!", 17);
	      BGL_DEFINE_STRING(BGl_string2392z00zz__threadz00,
		BgL_bgl_string2392za700za7za7_2640za7, "&%user-current-thread", 21);
	      BGL_DEFINE_STRING(BGl_string2393z00zz__threadz00,
		BgL_bgl_string2393za700za7za7_2641za7, "&%user-thread-sleep!", 20);
	     
		DEFINE_EXPORT_BGL_PROCEDURE(BGl_withzd2timedzd2lockzd2envzd2zz__threadz00,
		BgL_bgl_za762withza7d2timedza72642za7,
		BGl_z62withzd2timedzd2lockz62zz__threadz00, 0L, BUNSPEC, 3);
	      BGL_DEFINE_STRING(BGl_string2394z00zz__threadz00,
		BgL_bgl_string2394za700za7za7_2643za7, "&%user-thread-yield!", 20);
	      BGL_DEFINE_STRING(BGl_string2396z00zz__threadz00,
		BgL_bgl_string2396za700za7za7_2644za7, "tb-make-thread", 14);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
		BgL_bgl_za762tbza7d2mutexza7d22645za7,
		BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00, 0L, BUNSPEC, 2);
	      BGL_DEFINE_STRING(BGl_string2398z00zz__threadz00,
		BgL_bgl_string2398za700za7za7_2646za7, "tb-current-thread", 17);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2spec2647z00,
		BGl_z62threadzd2specificzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2specificzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2648z00,
		BGl_z62threadzd2specificzb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2395z00zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2649za7,
		BGl_z62tbzd2makezd2threadzd2nothr1182zb0zz__threadz00, 0L, BUNSPEC, 3);
	extern obj_t BGl_objectzd2printzd2envz00zz__objectz00;
	   
		 
		DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2397z00zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72650za7,
		BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2399z00zz__threadz00,
		BgL_bgl_za762objectza7d2disp2651z00, va_generic_entry,
		BGl_z62objectzd2displayzd2threa1190z62zz__threadz00, BUNSPEC, -2);
	extern obj_t BGl_objectzd2displayzd2envz00zz__objectz00;
	   
		 
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2star2652z00,
		BGl_z62threadzd2startzd2joinablez12z70zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2clea2653z00,
		BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2broadcastz12zd2envzc0zz__threadz00,
		BgL_bgl_za762conditionza7d2v2654z00,
		BGl_z62conditionzd2variablezd2broadcastz12z70zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2sleepz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2slee2655z00,
		BGl_z62threadzd2sleepz12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_defaultzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762defaultza7d2thr2656z00,
		BGl_z62defaultzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_getzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762getza7d2threadza72657za7,
		BGl_z62getzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2658za7,
		BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
		BgL_bgl_za762tbza7d2condvarza72659za7,
		BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2killz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2kill2660z00,
		BGl_z62threadzd2killz12za2zz__threadz00, 0L, BUNSPEC, 2);

/* contant bindings */
	static void bgl_constant_bindings()
	{
		BGL_BIND_PROCEDURE(BGl_threadzd2killz12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2kill2660z00);
		BGL_BIND_PROCEDURE(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
			BgL_bgl_za762tbza7d2condvarza72659za7);
		BGL_BIND_PROCEDURE(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
			BgL_bgl_za762za752userza7d2thr2658za7);
		BGL_BIND_PROCEDURE(BGl_getzd2threadzd2backendzd2envzd2zz__threadz00,
			BgL_bgl_za762getza7d2threadza72657za7);
		BGL_BIND_PROCEDURE(BGl_defaultzd2threadzd2backendzd2envzd2zz__threadz00,
			BgL_bgl_za762defaultza7d2thr2656z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2sleepz12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2slee2655z00);
		BGL_BIND_PROCEDURE
			(BGl_conditionzd2variablezd2broadcastz12zd2envzc0zz__threadz00,
			BgL_bgl_za762conditionza7d2v2654z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
			BgL_bgl_za762threadza7d2clea2653z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
			BgL_bgl_za762threadza7d2star2652z00);
		BGL_BIND_PROCEDURE(BGl_proc2399z00zz__threadz00,
			BgL_bgl_za762objectza7d2disp2651z00);
		BGL_BIND_PROCEDURE(BGl_proc2397z00zz__threadz00,
			BgL_bgl_za762tbza7d2currentza72650za7);
		BGL_BIND_PROCEDURE(BGl_proc2395z00zz__threadz00,
			BgL_bgl_za762tbza7d2makeza7d2t2649za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2specificzd2envz00zz__threadz00,
			BgL_bgl_za762threadza7d2spec2648z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
			BgL_bgl_za762threadza7d2spec2647z00);
		BGL_BIND_STRING(BGl_string2398z00zz__threadz00,
			BgL_bgl_string2398za700za7za7_2646za7);
		BGL_BIND_PROCEDURE(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
			BgL_bgl_za762tbza7d2mutexza7d22645za7);
		BGL_BIND_STRING(BGl_string2396z00zz__threadz00,
			BgL_bgl_string2396za700za7za7_2644za7);
		BGL_BIND_STRING(BGl_string2394z00zz__threadz00,
			BgL_bgl_string2394za700za7za7_2643za7);
		BGL_BIND_PROCEDURE(BGl_withzd2timedzd2lockzd2envzd2zz__threadz00,
			BgL_bgl_za762withza7d2timedza72642za7);
		BGL_BIND_STRING(BGl_string2393z00zz__threadz00,
			BgL_bgl_string2393za700za7za7_2641za7);
		BGL_BIND_STRING(BGl_string2392z00zz__threadz00,
			BgL_bgl_string2392za700za7za7_2640za7);
		BGL_BIND_STRING(BGl_string2391z00zz__threadz00,
			BgL_bgl_string2391za700za7za7_2639za7);
		BGL_BIND_STRING(BGl_string2390z00zz__threadz00,
			BgL_bgl_string2390za700za7za7_2638za7);
		BGL_BIND_PROCEDURE(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
			BgL_bgl_za762za752userza7d2thr2637za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2parameterzd2setz12zd2envzc0zz__threadz00,
			BgL_bgl_za762threadza7d2para2636z00);
		BGL_BIND_STRING(BGl_string2389z00zz__threadz00,
			BgL_bgl_string2389za700za7za7_2635za7);
		BGL_BIND_STRING(BGl_string2388z00zz__threadz00,
			BgL_bgl_string2388za700za7za7_2634za7);
		BGL_BIND_STRING(BGl_string2387z00zz__threadz00,
			BgL_bgl_string2387za700za7za7_2633za7);
		BGL_BIND_PROCEDURE(BGl_proc2299z00zz__threadz00,
			BgL_bgl_za762lambda1462za7622632z00);
		BGL_BIND_STRING(BGl_string2386z00zz__threadz00,
			BgL_bgl_string2386za700za7za7_2631za7);
		BGL_BIND_PROCEDURE(BGl_proc2298z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2630za7);
		BGL_BIND_STRING(BGl_string2385z00zz__threadz00,
			BgL_bgl_string2385za700za7za7_2629za7);
		BGL_BIND_STRING(BGl_string2384z00zz__threadz00,
			BgL_bgl_string2384za700za7za7_2628za7);
		BGL_BIND_STRING(BGl_string2383z00zz__threadz00,
			BgL_bgl_string2383za700za7za7_2627za7);
		BGL_BIND_PROCEDURE(BGl_proc2295z00zz__threadz00,
			BgL_bgl_za762lambda1454za7622626z00);
		BGL_BIND_STRING(BGl_string2382z00zz__threadz00,
			BgL_bgl_string2382za700za7za7_2625za7);
		BGL_BIND_PROCEDURE(BGl_proc2294z00zz__threadz00,
			BgL_bgl_za762lambda1455za7622624z00);
		BGL_BIND_STRING(BGl_string2381z00zz__threadz00,
			BgL_bgl_string2381za700za7za7_2623za7);
		BGL_BIND_PROCEDURE(BGl_proc2293z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2622za7);
		BGL_BIND_STRING(BGl_string2380z00zz__threadz00,
			BgL_bgl_string2380za700za7za7_2621za7);
		BGL_BIND_PROCEDURE(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
			BgL_bgl_za762tbza7d2currentza72620za7);
		BGL_BIND_PROCEDURE(BGl_proc2290z00zz__threadz00,
			BgL_bgl_za762lambda1446za7622619z00);
		BGL_BIND_PROCEDURE(BGl_makezd2mutexzd2envz00zz__threadz00,
			BgL_bgl__makeza7d2mutexza7d22618z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2yieldz12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2yiel2617z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2joinz12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2join2616z00);
		BGL_BIND_STRING(BGl_string2379z00zz__threadz00,
			BgL_bgl_string2379za700za7za7_2615za7);
		BGL_BIND_STRING(BGl_string2297z00zz__threadz00,
			BgL_bgl_string2297za700za7za7_2614za7);
		BGL_BIND_STRING(BGl_string2378z00zz__threadz00,
			BgL_bgl_string2378za700za7za7_2613za7);
		BGL_BIND_STRING(BGl_string2377z00zz__threadz00,
			BgL_bgl_string2377za700za7za7_2612za7);
		BGL_BIND_PROCEDURE(BGl_proc2289z00zz__threadz00,
			BgL_bgl_za762lambda1447za7622611z00);
		BGL_BIND_STRING(BGl_string2376z00zz__threadz00,
			BgL_bgl_string2376za700za7za7_2610za7);
		BGL_BIND_PROCEDURE(BGl_proc2288z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2609za7);
		BGL_BIND_STRING(BGl_string2292z00zz__threadz00,
			BgL_bgl_string2292za700za7za7_2608za7);
		BGL_BIND_PROCEDURE(BGl_proc2285z00zz__threadz00,
			BgL_bgl_za762lambda1437za7622607z00);
		BGL_BIND_PROCEDURE(BGl_proc2284z00zz__threadz00,
			BgL_bgl_za762lambda1438za7622606z00);
		BGL_BIND_PROCEDURE(BGl_mutexzd2unlockz12zd2envz12zz__threadz00,
			BgL_bgl_za762mutexza7d2unloc2605z00);
		BGL_BIND_PROCEDURE(BGl_proc2283z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2604za7);
		BGL_BIND_PROCEDURE(BGl_mutexzd2namezd2envz00zz__threadz00,
			BgL_bgl_za762mutexza7d2nameza72603za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
			BgL_bgl_za762threadza7d2name2602z00);
		BGL_BIND_STRING(BGl_string2287z00zz__threadz00,
			BgL_bgl_string2287za700za7za7_2601za7);
		BGL_BIND_PROCEDURE(BGl_withzd2lockzd2envz00zz__threadz00,
			BgL_bgl_za762withza7d2lockza7b2600za7);
		BGL_BIND_PROCEDURE(BGl_proc2279z00zz__threadz00,
			BgL_bgl_za762lambda1431za7622599z00);
		BGL_BIND_PROCEDURE(BGl_proc2278z00zz__threadz00,
			BgL_bgl_za762lambda1432za7622598z00);
		BGL_BIND_PROCEDURE(BGl_proc2277z00zz__threadz00,
			BgL_bgl_za762lambda1380za7622597z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2term2596z00);
		BGL_BIND_PROCEDURE(BGl_proc2276z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2595za7);
		BGL_BIND_PROCEDURE(BGl_proc2275z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2594za7);
		BGL_BIND_STRING(BGl_string2281z00zz__threadz00,
			BgL_bgl_string2281za700za7za7_2593za7);
		BGL_BIND_PROCEDURE(BGl_proc2274z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2592za7);
		BGL_BIND_PROCEDURE(BGl_proc2355z00zz__threadz00,
			BgL_bgl_za762za752userza7d2thr2591za7);
		BGL_BIND_STRING(BGl_string2361z00zz__threadz00,
			BgL_bgl_string2361za700za7za7_2590za7);
		BGL_BIND_PROCEDURE(BGl_proc2273z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2589za7);
		BGL_BIND_PROCEDURE(BGl_currentzd2dynamiczd2envzd2envzd2zz__threadz00,
			BgL_bgl_za762currentza7d2dyn2588z00);
		BGL_BIND_PROCEDURE(BGl_proc2272z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2587za7);
		BGL_BIND_PROCEDURE(BGl_proc2353z00zz__threadz00,
			BgL_bgl_za762za752userza7d2thr2586za7);
		BGL_BIND_PROCEDURE(BGl_mutexzd2lockz12zd2envz12zz__threadz00,
			BgL_bgl__mutexza7d2lockza7122585z00);
		BGL_BIND_PROCEDURE(BGl_conditionzd2variablezd2nilzd2envzd2zz__threadz00,
			BgL_bgl_za762conditionza7d2v2584z00);
		BGL_BIND_PROCEDURE(BGl_proc2351z00zz__threadz00,
			BgL_bgl_za762za752userza7d2cur2583za7);
		BGL_BIND_PROCEDURE(BGl_currentzd2threadzd2backendzd2envzd2zz__threadz00,
			BgL_bgl_za762currentza7d2thr2582z00);
		BGL_BIND_PROCEDURE(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
			BgL_bgl_za762threadza7d2init2581z00);
		BGL_BIND_STRING(BGl_string2359z00zz__threadz00,
			BgL_bgl_string2359za700za7za7_2580za7);
		BGL_BIND_STRING(BGl_string2358z00zz__threadz00,
			BgL_bgl_string2358za700za7za7_2579za7);
		BGL_BIND_PROCEDURE(BGl_proc2269z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2578za7);
		BGL_BIND_STRING(BGl_string2356z00zz__threadz00,
			BgL_bgl_string2356za700za7za7_2577za7);
		BGL_BIND_PROCEDURE(BGl_proc2268z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2576za7);
		BGL_BIND_PROCEDURE(BGl_proc2349z00zz__threadz00,
			BgL_bgl_za762threadza7d2name2575z00);
		BGL_BIND_STRING(BGl_string2354z00zz__threadz00,
			BgL_bgl_string2354za700za7za7_2574za7);
		BGL_BIND_PROCEDURE(BGl_proc2347z00zz__threadz00,
			BgL_bgl_za762threadza7d2name2573z00);
		BGL_BIND_PROCEDURE(BGl_proc2265z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2572za7);
		BGL_BIND_STRING(BGl_string2271z00zz__threadz00,
			BgL_bgl_string2271za700za7za7_2571za7);
		BGL_BIND_STRING(BGl_string2352z00zz__threadz00,
			BgL_bgl_string2352za700za7za7_2570za7);
		BGL_BIND_PROCEDURE(BGl_proc2264z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2569za7);
		BGL_BIND_PROCEDURE(BGl_proc2345z00zz__threadz00,
			BgL_bgl_za762threadza7d2clea2568z00);
		BGL_BIND_STRING(BGl_string2350z00zz__threadz00,
			BgL_bgl_string2350za700za7za7_2567za7);
		BGL_BIND_PROCEDURE(BGl_proc2425z00zz__threadz00,
			BgL_bgl_za762threadza7d2name2566z00);
		BGL_BIND_PROCEDURE(BGl_proc2343z00zz__threadz00,
			BgL_bgl_za762threadza7d2clea2565z00);
		BGL_BIND_PROCEDURE(BGl_proc2261z00zz__threadz00,
			BgL_bgl_za762lambda1387za7622564z00);
		BGL_BIND_PROCEDURE(BGl_proc2423z00zz__threadz00,
			BgL_bgl_za762threadza7d2name2563z00);
		BGL_BIND_PROCEDURE(BGl_proc2260z00zz__threadz00,
			BgL_bgl_za762lambda1388za7622562z00);
		BGL_BIND_PROCEDURE(BGl_proc2341z00zz__threadz00,
			BgL_bgl_za762threadza7d2spec2561z00);
		BGL_BIND_PROCEDURE(BGl_proc2421z00zz__threadz00,
			BgL_bgl_za762threadza7d2clea2560z00);
		BGL_BIND_PROCEDURE(BGl_mutexzd2statezd2envz00zz__threadz00,
			BgL_bgl_za762mutexza7d2state2559z00);
		BGL_BIND_STRING(BGl_string2267z00zz__threadz00,
			BgL_bgl_string2267za700za7za7_2558za7);
		BGL_BIND_STRING(BGl_string2348z00zz__threadz00,
			BgL_bgl_string2348za700za7za7_2557za7);
		BGL_BIND_STRING(BGl_string2429z00zz__threadz00,
			BgL_bgl_string2429za700za7za7_2556za7);
		BGL_BIND_STRING(BGl_string2428z00zz__threadz00,
			BgL_bgl_string2428za700za7za7_2555za7);
		BGL_BIND_PROCEDURE(BGl_proc2259z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2554za7);
		BGL_BIND_STRING(BGl_string2346z00zz__threadz00,
			BgL_bgl_string2346za700za7za7_2553za7);
		BGL_BIND_STRING(BGl_string2427z00zz__threadz00,
			BgL_bgl_string2427za700za7za7_2552za7);
		BGL_BIND_PROCEDURE(BGl_proc2339z00zz__threadz00,
			BgL_bgl_za762threadza7d2spec2551z00);
		BGL_BIND_STRING(BGl_string2426z00zz__threadz00,
			BgL_bgl_string2426za700za7za7_2550za7);
		BGL_BIND_STRING(BGl_string2263z00zz__threadz00,
			BgL_bgl_string2263za700za7za7_2549za7);
		BGL_BIND_STRING(BGl_string2344z00zz__threadz00,
			BgL_bgl_string2344za700za7za7_2548za7);
		BGL_BIND_PROCEDURE(BGl_proc2419z00zz__threadz00,
			BgL_bgl_za762threadza7d2clea2547z00);
		BGL_BIND_PROCEDURE(BGl_proc2337z00zz__threadz00,
			BgL_bgl_za762threadza7d2kill2546z00);
		BGL_BIND_STRING(BGl_string2424z00zz__threadz00,
			BgL_bgl_string2424za700za7za7_2545za7);
		BGL_BIND_PROCEDURE(BGl_proc2255z00zz__threadz00,
			BgL_bgl_za762lambda1366za7622544z00);
		BGL_BIND_STRING(BGl_string2342z00zz__threadz00,
			BgL_bgl_string2342za700za7za7_2543za7);
		BGL_BIND_PROCEDURE(BGl_proc2417z00zz__threadz00,
			BgL_bgl_za762threadza7d2spec2542z00);
		BGL_BIND_PROCEDURE(BGl_proc2254z00zz__threadz00,
			BgL_bgl_za762lambda1368za7622541z00);
		BGL_BIND_PROCEDURE(BGl_proc2335z00zz__threadz00,
			BgL_bgl_za762threadza7d2term2540z00);
		BGL_BIND_STRING(BGl_string2422z00zz__threadz00,
			BgL_bgl_string2422za700za7za7_2539za7);
		BGL_BIND_PROCEDURE(BGl_proc2253z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2538za7);
		BGL_BIND_STRING(BGl_string2340z00zz__threadz00,
			BgL_bgl_string2340za700za7za7_2537za7);
		BGL_BIND_PROCEDURE(BGl_proc2415z00zz__threadz00,
			BgL_bgl_za762threadza7d2spec2536z00);
		BGL_BIND_PROCEDURE(BGl_proc2333z00zz__threadz00,
			BgL_bgl_za762threadza7d2join2535z00);
		BGL_BIND_STRING(BGl_string2420z00zz__threadz00,
			BgL_bgl_string2420za700za7za7_2534za7);
		BGL_BIND_PROCEDURE(BGl_proc2413z00zz__threadz00,
			BgL_bgl_za762threadza7d2kill2533z00);
		BGL_BIND_PROCEDURE(BGl_proc2331z00zz__threadz00,
			BgL_bgl_za762threadza7d2star2532z00);
		BGL_BIND_PROCEDURE(BGl_proc2411z00zz__threadz00,
			BgL_bgl_za762threadza7d2term2531z00);
		BGL_BIND_PROCEDURE(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
			BgL_bgl_za762za752userza7d2cur2530za7);
		BGL_BIND_STRING(BGl_string2258z00zz__threadz00,
			BgL_bgl_string2258za700za7za7_2529za7);
		BGL_BIND_STRING(BGl_string2338z00zz__threadz00,
			BgL_bgl_string2338za700za7za7_2528za7);
		BGL_BIND_STRING(BGl_string2418z00zz__threadz00,
			BgL_bgl_string2418za700za7za7_2527za7);
		BGL_BIND_PROCEDURE(BGl_proc2249z00zz__threadz00,
			BgL_bgl_za762lambda1374za7622526z00);
		BGL_BIND_STRING(BGl_string2336z00zz__threadz00,
			BgL_bgl_string2336za700za7za7_2525za7);
		BGL_BIND_PROCEDURE(BGl_proc2248z00zz__threadz00,
			BgL_bgl_za762lambda1375za7622524z00);
		BGL_BIND_PROCEDURE(BGl_proc2329z00zz__threadz00,
			BgL_bgl_za762threadza7d2star2523z00);
		BGL_BIND_STRING(BGl_string2416z00zz__threadz00,
			BgL_bgl_string2416za700za7za7_2522za7);
		BGL_BIND_STRING(BGl_string2334z00zz__threadz00,
			BgL_bgl_string2334za700za7za7_2521za7);
		BGL_BIND_PROCEDURE(BGl_proc2409z00zz__threadz00,
			BgL_bgl_za762threadza7d2join2520z00);
		BGL_BIND_PROCEDURE(BGl_proc2327z00zz__threadz00,
			BgL_bgl_za762threadza7d2init2519z00);
		BGL_BIND_STRING(BGl_string2414z00zz__threadz00,
			BgL_bgl_string2414za700za7za7_2518za7);
		BGL_BIND_STRING(BGl_string2251z00zz__threadz00,
			BgL_bgl_string2251za700za7za7_2517za7);
		BGL_BIND_STRING(BGl_string2332z00zz__threadz00,
			BgL_bgl_string2332za700za7za7_2516za7);
		BGL_BIND_PROCEDURE(BGl_proc2407z00zz__threadz00,
			BgL_bgl_za762threadza7d2star2515z00);
		BGL_BIND_PROCEDURE(BGl_proc2325z00zz__threadz00,
			BgL_bgl_za762tbza7d2condvarza72514za7);
		BGL_BIND_STRING(BGl_string2412z00zz__threadz00,
			BgL_bgl_string2412za700za7za7_2513za7);
		BGL_BIND_STRING(BGl_string2330z00zz__threadz00,
			BgL_bgl_string2330za700za7za7_2512za7);
		BGL_BIND_PROCEDURE(BGl_proc2405z00zz__threadz00,
			BgL_bgl_za762threadza7d2star2511z00);
		BGL_BIND_PROCEDURE(BGl_proc2323z00zz__threadz00,
			BgL_bgl_za762tbza7d2mutexza7d22510za7);
		BGL_BIND_STRING(BGl_string2410z00zz__threadz00,
			BgL_bgl_string2410za700za7za7_2509za7);
		BGL_BIND_PROCEDURE(BGl_proc2403z00zz__threadz00,
			BgL_bgl_za762objectza7d2prin2508z00);
		BGL_BIND_PROCEDURE(BGl_proc2321z00zz__threadz00,
			BgL_bgl_za762tbza7d2currentza72507za7);
		BGL_BIND_PROCEDURE(BGl_proc2401z00zz__threadz00,
			BgL_bgl_za762objectza7d2writ2506z00);
		BGL_BIND_PROCEDURE(BGl_makezd2threadzd2envz00zz__threadz00,
			BgL_bgl__makeza7d2threadza7d2505z00);
		BGL_BIND_PROCEDURE(BGl_mutexzd2nilzd2envz00zz__threadz00,
			BgL_bgl_za762mutexza7d2nilza7b2504za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2startz12zd2envz12zz__threadz00,
			BgL_bgl_za762threadza7d2star2503z00);
		BGL_BIND_STRING(BGl_string2247z00zz__threadz00,
			BgL_bgl_string2247za700za7za7_2502za7);
		BGL_BIND_STRING(BGl_string2328z00zz__threadz00,
			BgL_bgl_string2328za700za7za7_2501za7);
		BGL_BIND_STRING(BGl_string2246z00zz__threadz00,
			BgL_bgl_string2246za700za7za7_2500za7);
		BGL_BIND_STRING(BGl_string2408z00zz__threadz00,
			BgL_bgl_string2408za700za7za7_2499za7);
		BGL_BIND_STRING(BGl_string2245z00zz__threadz00,
			BgL_bgl_string2245za700za7za7_2498za7);
		BGL_BIND_STRING(BGl_string2326z00zz__threadz00,
			BgL_bgl_string2326za700za7za7_2497za7);
		BGL_BIND_STRING(BGl_string2244z00zz__threadz00,
			BgL_bgl_string2244za700za7za7_2496za7);
		BGL_BIND_PROCEDURE(BGl_proc2319z00zz__threadz00,
			BgL_bgl_za762tbza7d2makeza7d2t2495za7);
		BGL_BIND_STRING(BGl_string2406z00zz__threadz00,
			BgL_bgl_string2406za700za7za7_2494za7);
		BGL_BIND_STRING(BGl_string2243z00zz__threadz00,
			BgL_bgl_string2243za700za7za7_2493za7);
		BGL_BIND_STRING(BGl_string2324z00zz__threadz00,
			BgL_bgl_string2324za700za7za7_2492za7);
		BGL_BIND_STRING(BGl_string2242z00zz__threadz00,
			BgL_bgl_string2242za700za7za7_2491za7);
		BGL_BIND_STRING(BGl_string2404z00zz__threadz00,
			BgL_bgl_string2404za700za7za7_2490za7);
		BGL_BIND_STRING(BGl_string2322z00zz__threadz00,
			BgL_bgl_string2322za700za7za7_2489za7);
		BGL_BIND_STRING(BGl_string2240z00zz__threadz00,
			BgL_bgl_string2240za700za7za7_2488za7);
		BGL_BIND_STRING(BGl_string2402z00zz__threadz00,
			BgL_bgl_string2402za700za7za7_2487za7);
		BGL_BIND_PROCEDURE(BGl_proc2314z00zz__threadz00,
			BgL_bgl_za762lambda1476za7622486z00);
		BGL_BIND_STRING(BGl_string2320z00zz__threadz00,
			BgL_bgl_string2320za700za7za7_2485za7);
		BGL_BIND_PROCEDURE(BGl_proc2313z00zz__threadz00,
			BgL_bgl_za762lambda1480za7622484z00);
		BGL_BIND_STRING(BGl_string2400z00zz__threadz00,
			BgL_bgl_string2400za700za7za7_2483za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2parameterzd2envz00zz__threadz00,
			BgL_bgl_za762threadza7d2para2482z00);
		BGL_BIND_PROCEDURE(BGl_proc2312z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2481za7);
		BGL_BIND_PROCEDURE(BGl_proc2310z00zz__threadz00,
			BgL_bgl_za762lambda1422za7622480z00);
		BGL_BIND_PROCEDURE(BGl_mutexzf3zd2envz21zz__threadz00,
			BgL_bgl_za762mutexza7f3za791za7za72479za7);
		BGL_BIND_STRING(BGl_string2239z00zz__threadz00,
			BgL_bgl_string2239za700za7za7_2478za7);
		BGL_BIND_STRING(BGl_string2238z00zz__threadz00,
			BgL_bgl_string2238za700za7za7_2477za7);
		BGL_BIND_STRING(BGl_string2237z00zz__threadz00,
			BgL_bgl_string2237za700za7za7_2476za7);
		BGL_BIND_STRING(BGl_string2318z00zz__threadz00,
			BgL_bgl_string2318za700za7za7_2475za7);
		BGL_BIND_STRING(BGl_string2236z00zz__threadz00,
			BgL_bgl_string2236za700za7za7_2474za7);
		BGL_BIND_STRING(BGl_string2317z00zz__threadz00,
			BgL_bgl_string2317za700za7za7_2473za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2cleanupzd2envz00zz__threadz00,
			BgL_bgl_za762threadza7d2clea2472z00);
		BGL_BIND_STRING(BGl_string2235z00zz__threadz00,
			BgL_bgl_string2235za700za7za7_2471za7);
		BGL_BIND_STRING(BGl_string2316z00zz__threadz00,
			BgL_bgl_string2316za700za7za7_2470za7);
		BGL_BIND_STRING(BGl_string2234z00zz__threadz00,
			BgL_bgl_string2234za700za7za7_2469za7);
		BGL_BIND_PROCEDURE(BGl_proc2309z00zz__threadz00,
			BgL_bgl_za762lambda1425za7622468z00);
		BGL_BIND_STRING(BGl_string2233z00zz__threadz00,
			BgL_bgl_string2233za700za7za7_2467za7);
		BGL_BIND_PROCEDURE(BGl_proc2308z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2466za7);
		BGL_BIND_STRING(BGl_string2232z00zz__threadz00,
			BgL_bgl_string2232za700za7za7_2465za7);
		BGL_BIND_PROCEDURE(BGl_currentzd2threadzd2envz00zz__threadz00,
			BgL_bgl_za762currentza7d2thr2464z00);
		BGL_BIND_PROCEDURE(BGl_conditionzd2variablezd2namezd2envzd2zz__threadz00,
			BgL_bgl_za762conditionza7d2v2463z00);
		BGL_BIND_STRING(BGl_string2230z00zz__threadz00,
			BgL_bgl_string2230za700za7za7_2462za7);
		BGL_BIND_PROCEDURE(BGl_proc2305z00zz__threadz00,
			BgL_bgl_za762lambda1468za7622461z00);
		BGL_BIND_PROCEDURE(BGl_proc2304z00zz__threadz00,
			BgL_bgl_za762lambda1469za7622460z00);
		BGL_BIND_PROCEDURE(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
			BgL_bgl_za762tbza7d2makeza7d2t2459za7);
		BGL_BIND_PROCEDURE(BGl_proc2303z00zz__threadz00,
			BgL_bgl_za762za7c3za704anonymo2458za7);
		BGL_BIND_PROCEDURE(BGl_proc2300z00zz__threadz00,
			BgL_bgl_za762lambda1461za7622457z00);
		BGL_BIND_STRING(BGl_string2229z00zz__threadz00,
			BgL_bgl_string2229za700za7za7_2456za7);
		BGL_BIND_PROCEDURE(BGl_makezd2spinlockzd2envz00zz__threadz00,
			BgL_bgl__makeza7d2spinlock2455za7);
		BGL_BIND_STRING(BGl_string2227z00zz__threadz00,
			BgL_bgl_string2227za700za7za7_2454za7);
		BGL_BIND_STRING(BGl_string2226z00zz__threadz00,
			BgL_bgl_string2226za700za7za7_2453za7);
		BGL_BIND_STRING(BGl_string2307z00zz__threadz00,
			BgL_bgl_string2307za700za7za7_2452za7);
		BGL_BIND_STRING(BGl_string2225z00zz__threadz00,
			BgL_bgl_string2225za700za7za7_2451za7);
		BGL_BIND_STRING(BGl_string2224z00zz__threadz00,
			BgL_bgl_string2224za700za7za7_2450za7);
		BGL_BIND_STRING(BGl_string2223z00zz__threadz00,
			BgL_bgl_string2223za700za7za7_2449za7);
		BGL_BIND_STRING(BGl_string2222z00zz__threadz00,
			BgL_bgl_string2222za700za7za7_2448za7);
		BGL_BIND_STRING(BGl_string2302z00zz__threadz00,
			BgL_bgl_string2302za700za7za7_2447za7);
		BGL_BIND_STRING(BGl_string2220z00zz__threadz00,
			BgL_bgl_string2220za700za7za7_2446za7);
		BGL_BIND_PROCEDURE(BGl_threadzd2namezd2envz00zz__threadz00,
			BgL_bgl_za762threadza7d2name2445z00);
		BGL_BIND_PROCEDURE
			(BGl_defaultzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
			BgL_bgl_za762defaultza7d2thr2444z00);
		BGL_BIND_PROCEDURE(BGl_conditionzd2variablezf3zd2envzf3zz__threadz00,
			BgL_bgl_za762conditionza7d2v2443z00);
		BGL_BIND_PROCEDURE
			(BGl_currentzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
			BgL_bgl_za762currentza7d2thr2442z00);
		BGL_BIND_STRING(BGl_string2219z00zz__threadz00,
			BgL_bgl_string2219za700za7za7_2441za7);
		BGL_BIND_STRING(BGl_string2218z00zz__threadz00,
			BgL_bgl_string2218za700za7za7_2440za7);
		BGL_BIND_STRING(BGl_string2217z00zz__threadz00,
			BgL_bgl_string2217za700za7za7_2439za7);
		BGL_BIND_STRING(BGl_string2216z00zz__threadz00,
			BgL_bgl_string2216za700za7za7_2438za7);
		BGL_BIND_STRING(BGl_string2215z00zz__threadz00,
			BgL_bgl_string2215za700za7za7_2437za7);
		BGL_BIND_STRING(BGl_string2214z00zz__threadz00,
			BgL_bgl_string2214za700za7za7_2436za7);
		BGL_BIND_STRING(BGl_string2213z00zz__threadz00,
			BgL_bgl_string2213za700za7za7_2435za7);
		BGL_BIND_STRING(BGl_string2212z00zz__threadz00,
			BgL_bgl_string2212za700za7za7_2434za7);
		BGL_BIND_PROCEDURE
			(BGl_conditionzd2variablezd2signalz12zd2envzc0zz__threadz00,
			BgL_bgl_za762conditionza7d2v2433z00);
		BGL_BIND_PROCEDURE(BGl_conditionzd2variablezd2waitz12zd2envzc0zz__threadz00,
			BgL_bgl__conditionza7d2var2432za7);
		BGL_BIND_PROCEDURE(BGl_dynamiczd2envzf3zd2envzf3zz__threadz00,
			BgL_bgl_za762dynamicza7d2env2431z00);
		BGL_BIND_PROCEDURE(BGl_makezd2conditionzd2variablezd2envzd2zz__threadz00,
			BgL_bgl__makeza7d2conditio2430za7);
	}

/* GC roots registration */
	static obj_t bgl_gc_roots_register()
	{
#if defined( BGL_GC_ROOTS )
#define ADD_ROOT( addr ) (addr > roots_max ? roots_max = addr : (addr < roots_min ? roots_min = addr : 0))
		void *roots_min = (void *) ULONG_MAX, *roots_max = 0;

		ADD_ROOT((void *) (&BGl_requirezd2initializa7ationz75zz__threadz00));
		ADD_ROOT((void *) (&BGl_za2threadzd2backendsza2zd2zz__threadz00));
		ADD_ROOT((void *) (&BGl_nothreadzd2backendzd2zz__threadz00));
		ADD_ROOT((void *) (&BGl_za2nothreadzd2backendza2zd2zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2301z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2221z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2306z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2228z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2311z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2231z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2315z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2241z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2250z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2252z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2256z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2257z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2262z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2266z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2270z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2357z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_nothreadz00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2360z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2280z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2362z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2363z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2282z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2364z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2365z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2366z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2367z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2286z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2368z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2369z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_za2nothreadzd2currentza2zd2zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2370z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2371z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2372z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2291z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2373z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2374z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2375z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_symbol2296z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_za2mutexzd2nilza2zd2zz__threadz00));
		ADD_ROOT((void *) (&BGl_za2conditionzd2variablezd2nilza2z00zz__threadz00));
		ADD_ROOT((void *) (&BGl_threadz00zz__threadz00));
		ADD_ROOT((void *) (&BGl_threadzd2backendzd2zz__threadz00));
#undef ADD_ROOT
		if (roots_max > 0)
			GC_add_roots(roots_min, ((void **) roots_max) + 1);
#endif
		return BUNSPEC;
	}



/* module-initialization */
	BGL_EXPORTED_DEF obj_t BGl_modulezd2initializa7ationz75zz__threadz00(long
		BgL_checksumz00_5054, char *BgL_fromz00_5055)
	{
		{
			if (CBOOL(BGl_requirezd2initializa7ationz75zz__threadz00))
				{
					BGl_requirezd2initializa7ationz75zz__threadz00 = BBOOL(((bool_t) 0));
					bgl_constant_bindings();
					BGl_gczd2rootszd2initz00zz__threadz00();
					BGl_cnstzd2initzd2zz__threadz00();
					BGl_importedzd2moduleszd2initz00zz__threadz00();
					BGl_objectzd2initzd2zz__threadz00();
					BGl_genericzd2initzd2zz__threadz00();
					BGl_methodzd2initzd2zz__threadz00();
					return BGl_toplevelzd2initzd2zz__threadz00();
				}
			else
				{
					return BUNSPEC;
				}
		}

	}



/* cnst-init */
	obj_t BGl_cnstzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_symbol2221z00zz__threadz00 =
				bstring_to_symbol(BGl_string2222z00zz__threadz00);
			BGl_symbol2228z00zz__threadz00 =
				bstring_to_symbol(BGl_string2229z00zz__threadz00);
			BGl_symbol2231z00zz__threadz00 =
				bstring_to_symbol(BGl_string2232z00zz__threadz00);
			BGl_symbol2241z00zz__threadz00 =
				bstring_to_symbol(BGl_string2242z00zz__threadz00);
			BGl_symbol2250z00zz__threadz00 =
				bstring_to_symbol(BGl_string2251z00zz__threadz00);
			BGl_symbol2252z00zz__threadz00 =
				bstring_to_symbol(BGl_string2218z00zz__threadz00);
			BGl_symbol2256z00zz__threadz00 =
				bstring_to_symbol(BGl_string2215z00zz__threadz00);
			BGl_symbol2257z00zz__threadz00 =
				bstring_to_symbol(BGl_string2258z00zz__threadz00);
			BGl_symbol2262z00zz__threadz00 =
				bstring_to_symbol(BGl_string2263z00zz__threadz00);
			BGl_symbol2266z00zz__threadz00 =
				bstring_to_symbol(BGl_string2267z00zz__threadz00);
			BGl_symbol2270z00zz__threadz00 =
				bstring_to_symbol(BGl_string2271z00zz__threadz00);
			BGl_symbol2280z00zz__threadz00 =
				bstring_to_symbol(BGl_string2281z00zz__threadz00);
			BGl_symbol2282z00zz__threadz00 =
				bstring_to_symbol(BGl_string2223z00zz__threadz00);
			BGl_symbol2286z00zz__threadz00 =
				bstring_to_symbol(BGl_string2287z00zz__threadz00);
			BGl_symbol2291z00zz__threadz00 =
				bstring_to_symbol(BGl_string2292z00zz__threadz00);
			BGl_symbol2296z00zz__threadz00 =
				bstring_to_symbol(BGl_string2297z00zz__threadz00);
			BGl_symbol2301z00zz__threadz00 =
				bstring_to_symbol(BGl_string2302z00zz__threadz00);
			BGl_symbol2306z00zz__threadz00 =
				bstring_to_symbol(BGl_string2307z00zz__threadz00);
			BGl_symbol2311z00zz__threadz00 =
				bstring_to_symbol(BGl_string2212z00zz__threadz00);
			BGl_symbol2315z00zz__threadz00 =
				bstring_to_symbol(BGl_string2316z00zz__threadz00);
			BGl_symbol2357z00zz__threadz00 =
				bstring_to_symbol(BGl_string2358z00zz__threadz00);
			BGl_symbol2360z00zz__threadz00 =
				bstring_to_symbol(BGl_string2350z00zz__threadz00);
			BGl_symbol2362z00zz__threadz00 =
				bstring_to_symbol(BGl_string2348z00zz__threadz00);
			BGl_symbol2363z00zz__threadz00 =
				bstring_to_symbol(BGl_string2346z00zz__threadz00);
			BGl_symbol2364z00zz__threadz00 =
				bstring_to_symbol(BGl_string2344z00zz__threadz00);
			BGl_symbol2365z00zz__threadz00 =
				bstring_to_symbol(BGl_string2342z00zz__threadz00);
			BGl_symbol2366z00zz__threadz00 =
				bstring_to_symbol(BGl_string2340z00zz__threadz00);
			BGl_symbol2367z00zz__threadz00 =
				bstring_to_symbol(BGl_string2338z00zz__threadz00);
			BGl_symbol2368z00zz__threadz00 =
				bstring_to_symbol(BGl_string2336z00zz__threadz00);
			BGl_symbol2369z00zz__threadz00 =
				bstring_to_symbol(BGl_string2334z00zz__threadz00);
			BGl_symbol2370z00zz__threadz00 =
				bstring_to_symbol(BGl_string2332z00zz__threadz00);
			BGl_symbol2371z00zz__threadz00 =
				bstring_to_symbol(BGl_string2330z00zz__threadz00);
			BGl_symbol2372z00zz__threadz00 =
				bstring_to_symbol(BGl_string2326z00zz__threadz00);
			BGl_symbol2373z00zz__threadz00 =
				bstring_to_symbol(BGl_string2324z00zz__threadz00);
			BGl_symbol2374z00zz__threadz00 =
				bstring_to_symbol(BGl_string2322z00zz__threadz00);
			return (BGl_symbol2375z00zz__threadz00 =
				bstring_to_symbol(BGl_string2320z00zz__threadz00), BUNSPEC);
		}

	}



/* gc-roots-init */
	obj_t BGl_gczd2rootszd2initz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			return bgl_gc_roots_register();
		}

	}



/* toplevel-init */
	obj_t BGl_toplevelzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			{	/* Llib/thread.scm 272 */
				BgL_nothreadzd2backendzd2_bglt BgL_new1058z00_1226;

				{	/* Llib/thread.scm 273 */
					BgL_nothreadzd2backendzd2_bglt BgL_new1057z00_1227;

					BgL_new1057z00_1227 =
						((BgL_nothreadzd2backendzd2_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_nothreadzd2backendzd2_bgl))));
					{	/* Llib/thread.scm 273 */
						long BgL_arg1322z00_1228;

						BgL_arg1322z00_1228 =
							BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1057z00_1227), BgL_arg1322z00_1228);
					}
					BgL_new1058z00_1226 = BgL_new1057z00_1227;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1058z00_1226)))->
						BgL_namez00) = ((obj_t) BGl_string2212z00zz__threadz00), BUNSPEC);
				BGl_za2nothreadzd2backendza2zd2zz__threadz00 = BgL_new1058z00_1226;
			}
			{	/* Llib/thread.scm 279 */
				obj_t BgL_list1323z00_1229;

				BgL_list1323z00_1229 =
					MAKE_YOUNG_PAIR(
					((obj_t) BGl_za2nothreadzd2backendza2zd2zz__threadz00), BNIL);
				BGl_za2threadzd2backendsza2zd2zz__threadz00 = BgL_list1323z00_1229;
			}
			BGl_za2nothreadzd2currentza2zd2zz__threadz00 = BFALSE;
			BGl_za2mutexzd2nilza2zd2zz__threadz00 = bgl_make_nil_mutex();
			return (BGl_za2conditionzd2variablezd2nilza2z00zz__threadz00 =
				bgl_make_nil_condvar(), BUNSPEC);
		}

	}



/* dynamic-env? */
	BGL_EXPORTED_DEF bool_t BGl_dynamiczd2envzf3z21zz__threadz00(obj_t
		BgL_objz00_3)
	{
		{	/* Llib/thread.scm 259 */
			return BGL_DYNAMIC_ENVP(BgL_objz00_3);
		}

	}



/* &dynamic-env? */
	obj_t BGl_z62dynamiczd2envzf3z43zz__threadz00(obj_t BgL_envz00_3498,
		obj_t BgL_objz00_3499)
	{
		{	/* Llib/thread.scm 259 */
			return BBOOL(BGl_dynamiczd2envzf3z21zz__threadz00(BgL_objz00_3499));
		}

	}



/* current-dynamic-env */
	BGL_EXPORTED_DEF obj_t BGl_currentzd2dynamiczd2envz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 265 */
			return BGL_CURRENT_DYNAMIC_ENV();
		}

	}



/* &current-dynamic-env */
	obj_t BGl_z62currentzd2dynamiczd2envz62zz__threadz00(obj_t BgL_envz00_3500)
	{
		{	/* Llib/thread.scm 265 */
			return BGl_currentzd2dynamiczd2envz00zz__threadz00();
		}

	}



/* current-thread-backend */
	BGL_EXPORTED_DEF obj_t BGl_currentzd2threadzd2backendz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 284 */
			return BGL_THREAD_BACKEND();
		}

	}



/* &current-thread-backend */
	obj_t BGl_z62currentzd2threadzd2backendz62zz__threadz00(obj_t BgL_envz00_3501)
	{
		{	/* Llib/thread.scm 284 */
			return BGl_currentzd2threadzd2backendz00zz__threadz00();
		}

	}



/* current-thread-backend-set! */
	BGL_EXPORTED_DEF obj_t
		BGl_currentzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt BgL_tbz00_4)
	{
		{	/* Llib/thread.scm 290 */
			{	/* Llib/thread.scm 291 */
				obj_t BgL_tmpz00_5121;

				BgL_tmpz00_5121 = ((obj_t) BgL_tbz00_4);
				BGL_THREAD_BACKEND_SET(BgL_tmpz00_5121);
			}
			BUNSPEC;
			return ((obj_t) BgL_tbz00_4);
		}

	}



/* &current-thread-backend-set! */
	obj_t BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t
		BgL_envz00_3502, obj_t BgL_tbz00_3503)
	{
		{	/* Llib/thread.scm 290 */
			{	/* Llib/thread.scm 291 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5125;

				if (BGl_isazf3zf3zz__objectz00(BgL_tbz00_3503,
						BGl_threadzd2backendzd2zz__threadz00))
					{	/* Llib/thread.scm 291 */
						BgL_auxz00_5125 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3503);
					}
				else
					{
						obj_t BgL_auxz00_5129;

						BgL_auxz00_5129 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(11215L), BGl_string2214z00zz__threadz00,
							BGl_string2215z00zz__threadz00, BgL_tbz00_3503);
						FAILURE(BgL_auxz00_5129, BFALSE, BFALSE);
					}
				return
					BGl_currentzd2threadzd2backendzd2setz12zc0zz__threadz00
					(BgL_auxz00_5125);
			}
		}

	}



/* default-thread-backend */
	BGL_EXPORTED_DEF obj_t BGl_defaultzd2threadzd2backendz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 297 */
			return CAR(BGl_za2threadzd2backendsza2zd2zz__threadz00);
		}

	}



/* &default-thread-backend */
	obj_t BGl_z62defaultzd2threadzd2backendz62zz__threadz00(obj_t BgL_envz00_3504)
	{
		{	/* Llib/thread.scm 297 */
			return BGl_defaultzd2threadzd2backendz00zz__threadz00();
		}

	}



/* default-thread-backend-set! */
	BGL_EXPORTED_DEF obj_t
		BGl_defaultzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt BgL_tbz00_5)
	{
		{	/* Llib/thread.scm 303 */
			BGl_za2threadzd2backendsza2zd2zz__threadz00 =
				bgl_remq_bang(
				((obj_t) BgL_tbz00_5), BGl_za2threadzd2backendsza2zd2zz__threadz00);
			return (BGl_za2threadzd2backendsza2zd2zz__threadz00 =
				MAKE_YOUNG_PAIR(
					((obj_t) BgL_tbz00_5), BGl_za2threadzd2backendsza2zd2zz__threadz00),
				BUNSPEC);
		}

	}



/* &default-thread-backend-set! */
	obj_t BGl_z62defaultzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t
		BgL_envz00_3505, obj_t BgL_tbz00_3506)
	{
		{	/* Llib/thread.scm 303 */
			{	/* Llib/thread.scm 304 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5140;

				if (BGl_isazf3zf3zz__objectz00(BgL_tbz00_3506,
						BGl_threadzd2backendzd2zz__threadz00))
					{	/* Llib/thread.scm 304 */
						BgL_auxz00_5140 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3506);
					}
				else
					{
						obj_t BgL_auxz00_5144;

						BgL_auxz00_5144 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(11833L), BGl_string2216z00zz__threadz00,
							BGl_string2215z00zz__threadz00, BgL_tbz00_3506);
						FAILURE(BgL_auxz00_5144, BFALSE, BFALSE);
					}
				return
					BGl_defaultzd2threadzd2backendzd2setz12zc0zz__threadz00
					(BgL_auxz00_5140);
			}
		}

	}



/* get-thread-backend */
	BGL_EXPORTED_DEF obj_t BGl_getzd2threadzd2backendz00zz__threadz00(obj_t
		BgL_namez00_6)
	{
		{	/* Llib/thread.scm 310 */
			{
				obj_t BgL_tbsz00_1240;

				BgL_tbsz00_1240 = BGl_za2threadzd2backendsza2zd2zz__threadz00;
			BgL_zc3z04anonymousza31331ze3z87_1241:
				if (PAIRP(BgL_tbsz00_1240))
					{	/* Llib/thread.scm 313 */
						BgL_threadzd2backendzd2_bglt BgL_i1059z00_1243;

						BgL_i1059z00_1243 =
							((BgL_threadzd2backendzd2_bglt) CAR(BgL_tbsz00_1240));
						{	/* Llib/thread.scm 314 */
							bool_t BgL_test2665z00_5153;

							{	/* Llib/thread.scm 314 */
								obj_t BgL_arg1336z00_1247;

								BgL_arg1336z00_1247 =
									(((BgL_threadzd2backendzd2_bglt) COBJECT(BgL_i1059z00_1243))->
									BgL_namez00);
								{	/* Llib/thread.scm 314 */
									long BgL_l1z00_2223;

									BgL_l1z00_2223 = STRING_LENGTH(BgL_arg1336z00_1247);
									if ((BgL_l1z00_2223 == STRING_LENGTH(BgL_namez00_6)))
										{	/* Llib/thread.scm 314 */
											int BgL_arg1646z00_2226;

											{	/* Llib/thread.scm 314 */
												char *BgL_auxz00_5161;
												char *BgL_tmpz00_5159;

												BgL_auxz00_5161 = BSTRING_TO_STRING(BgL_namez00_6);
												BgL_tmpz00_5159 =
													BSTRING_TO_STRING(BgL_arg1336z00_1247);
												BgL_arg1646z00_2226 =
													memcmp(BgL_tmpz00_5159, BgL_auxz00_5161,
													BgL_l1z00_2223);
											}
											BgL_test2665z00_5153 =
												((long) (BgL_arg1646z00_2226) == 0L);
										}
									else
										{	/* Llib/thread.scm 314 */
											BgL_test2665z00_5153 = ((bool_t) 0);
										}
								}
							}
							if (BgL_test2665z00_5153)
								{	/* Llib/thread.scm 314 */
									return CAR(BgL_tbsz00_1240);
								}
							else
								{
									obj_t BgL_tbsz00_5167;

									BgL_tbsz00_5167 = CDR(BgL_tbsz00_1240);
									BgL_tbsz00_1240 = BgL_tbsz00_5167;
									goto BgL_zc3z04anonymousza31331ze3z87_1241;
								}
						}
					}
				else
					{	/* Llib/thread.scm 312 */
						return BFALSE;
					}
			}
		}

	}



/* &get-thread-backend */
	obj_t BGl_z62getzd2threadzd2backendz62zz__threadz00(obj_t BgL_envz00_3507,
		obj_t BgL_namez00_3508)
	{
		{	/* Llib/thread.scm 310 */
			{	/* Llib/thread.scm 312 */
				obj_t BgL_auxz00_5169;

				if (STRINGP(BgL_namez00_3508))
					{	/* Llib/thread.scm 312 */
						BgL_auxz00_5169 = BgL_namez00_3508;
					}
				else
					{
						obj_t BgL_auxz00_5172;

						BgL_auxz00_5172 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(12194L), BGl_string2217z00zz__threadz00,
							BGl_string2218z00zz__threadz00, BgL_namez00_3508);
						FAILURE(BgL_auxz00_5172, BFALSE, BFALSE);
					}
				return BGl_getzd2threadzd2backendz00zz__threadz00(BgL_auxz00_5169);
			}
		}

	}



/* _make-thread */
	obj_t BGl__makezd2threadzd2zz__threadz00(obj_t BgL_env1221z00_47,
		obj_t BgL_opt1220z00_46)
	{
		{	/* Llib/thread.scm 445 */
			{	/* Llib/thread.scm 445 */
				obj_t BgL_g1222z00_4093;

				{
					obj_t BgL_auxz00_5177;

					if (VECTORP(BgL_opt1220z00_46))
						{	/* Llib/thread.scm 445 */
							BgL_auxz00_5177 = BgL_opt1220z00_46;
						}
					else
						{
							obj_t BgL_auxz00_5180;

							BgL_auxz00_5180 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(19158L), BGl_string2219z00zz__threadz00,
								BGl_string2220z00zz__threadz00, BgL_opt1220z00_46);
							FAILURE(BgL_auxz00_5180, BFALSE, BFALSE);
						}
					BgL_g1222z00_4093 = VECTOR_REF(BgL_auxz00_5177, 0L);
				}
				{	/* Llib/thread.scm 445 */
					long BgL_aux1224z00_4094;

					{
						obj_t BgL_auxz00_5185;

						if (VECTORP(BgL_opt1220z00_46))
							{	/* Llib/thread.scm 445 */
								BgL_auxz00_5185 = BgL_opt1220z00_46;
							}
						else
							{
								obj_t BgL_auxz00_5188;

								BgL_auxz00_5188 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(19158L),
									BGl_string2219z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1220z00_46);
								FAILURE(BgL_auxz00_5188, BFALSE, BFALSE);
							}
						BgL_aux1224z00_4094 = VECTOR_LENGTH(BgL_auxz00_5185);
					}
					switch (BgL_aux1224z00_4094)
						{
						case 1L:

							{	/* Llib/thread.scm 445 */
								obj_t BgL_namez00_4095;

								BgL_namez00_4095 =
									BGl_gensymz00zz__r4_symbols_6_4z00
									(BGl_symbol2221z00zz__threadz00);
								{	/* Llib/thread.scm 445 */

									{	/* Llib/thread.scm 445 */
										obj_t BgL_bodyz00_4096;

										if (PROCEDUREP(BgL_g1222z00_4093))
											{	/* Llib/thread.scm 445 */
												BgL_bodyz00_4096 = BgL_g1222z00_4093;
											}
										else
											{
												obj_t BgL_auxz00_5196;

												BgL_auxz00_5196 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2213z00zz__threadz00, BINT(19158L),
													BGl_string2219z00zz__threadz00,
													BGl_string2223z00zz__threadz00, BgL_g1222z00_4093);
												FAILURE(BgL_auxz00_5196, BFALSE, BFALSE);
											}
										{	/* Llib/thread.scm 446 */
											obj_t BgL_arg1337z00_4097;

											BgL_arg1337z00_4097 =
												BGl_defaultzd2threadzd2backendz00zz__threadz00();
											{
												BgL_threadz00_bglt BgL_auxz00_5201;

												{	/* Llib/thread.scm 446 */
													BgL_threadzd2backendzd2_bglt BgL_auxz00_5202;

													if (BGl_isazf3zf3zz__objectz00(BgL_arg1337z00_4097,
															BGl_threadzd2backendzd2zz__threadz00))
														{	/* Llib/thread.scm 446 */
															BgL_auxz00_5202 =
																((BgL_threadzd2backendzd2_bglt)
																BgL_arg1337z00_4097);
														}
													else
														{
															obj_t BgL_auxz00_5206;

															BgL_auxz00_5206 =
																BGl_typezd2errorzd2zz__errorz00
																(BGl_string2213z00zz__threadz00, BINT(19269L),
																BGl_string2219z00zz__threadz00,
																BGl_string2215z00zz__threadz00,
																BgL_arg1337z00_4097);
															FAILURE(BgL_auxz00_5206, BFALSE, BFALSE);
														}
													BgL_auxz00_5201 =
														BGl_tbzd2makezd2threadz00zz__threadz00
														(BgL_auxz00_5202, BgL_bodyz00_4096,
														BgL_namez00_4095);
												}
												return ((obj_t) BgL_auxz00_5201);
											}
										}
									}
								}
							}
							break;
						case 2L:

							{	/* Llib/thread.scm 445 */
								obj_t BgL_namez00_4098;

								{
									obj_t BgL_auxz00_5212;

									if (VECTORP(BgL_opt1220z00_46))
										{	/* Llib/thread.scm 445 */
											BgL_auxz00_5212 = BgL_opt1220z00_46;
										}
									else
										{
											obj_t BgL_auxz00_5215;

											BgL_auxz00_5215 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(19158L),
												BGl_string2219z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1220z00_46);
											FAILURE(BgL_auxz00_5215, BFALSE, BFALSE);
										}
									BgL_namez00_4098 = VECTOR_REF(BgL_auxz00_5212, 1L);
								}
								{	/* Llib/thread.scm 445 */

									{	/* Llib/thread.scm 445 */
										obj_t BgL_bodyz00_4099;

										if (PROCEDUREP(BgL_g1222z00_4093))
											{	/* Llib/thread.scm 445 */
												BgL_bodyz00_4099 = BgL_g1222z00_4093;
											}
										else
											{
												obj_t BgL_auxz00_5222;

												BgL_auxz00_5222 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2213z00zz__threadz00, BINT(19158L),
													BGl_string2219z00zz__threadz00,
													BGl_string2223z00zz__threadz00, BgL_g1222z00_4093);
												FAILURE(BgL_auxz00_5222, BFALSE, BFALSE);
											}
										{	/* Llib/thread.scm 446 */
											obj_t BgL_arg1337z00_4100;

											BgL_arg1337z00_4100 =
												BGl_defaultzd2threadzd2backendz00zz__threadz00();
											{
												BgL_threadz00_bglt BgL_auxz00_5227;

												{	/* Llib/thread.scm 446 */
													BgL_threadzd2backendzd2_bglt BgL_auxz00_5228;

													if (BGl_isazf3zf3zz__objectz00(BgL_arg1337z00_4100,
															BGl_threadzd2backendzd2zz__threadz00))
														{	/* Llib/thread.scm 446 */
															BgL_auxz00_5228 =
																((BgL_threadzd2backendzd2_bglt)
																BgL_arg1337z00_4100);
														}
													else
														{
															obj_t BgL_auxz00_5232;

															BgL_auxz00_5232 =
																BGl_typezd2errorzd2zz__errorz00
																(BGl_string2213z00zz__threadz00, BINT(19269L),
																BGl_string2219z00zz__threadz00,
																BGl_string2215z00zz__threadz00,
																BgL_arg1337z00_4100);
															FAILURE(BgL_auxz00_5232, BFALSE, BFALSE);
														}
													BgL_auxz00_5227 =
														BGl_tbzd2makezd2threadz00zz__threadz00
														(BgL_auxz00_5228, BgL_bodyz00_4099,
														BgL_namez00_4098);
												}
												return ((obj_t) BgL_auxz00_5227);
											}
										}
									}
								}
							}
							break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* make-thread */
	BGL_EXPORTED_DEF BgL_threadz00_bglt BGl_makezd2threadzd2zz__threadz00(obj_t
		BgL_bodyz00_44, obj_t BgL_namez00_45)
	{
		{	/* Llib/thread.scm 445 */
			{	/* Llib/thread.scm 446 */
				obj_t BgL_arg1337z00_4101;

				BgL_arg1337z00_4101 = BGl_defaultzd2threadzd2backendz00zz__threadz00();
				return
					BGl_tbzd2makezd2threadz00zz__threadz00(
					((BgL_threadzd2backendzd2_bglt) BgL_arg1337z00_4101), BgL_bodyz00_44,
					BgL_namez00_45);
			}
		}

	}



/* %current-thread */
	obj_t BGl_z52currentzd2threadz80zz__threadz00(void)
	{
		{	/* Llib/thread.scm 457 */
			{	/* Llib/thread.scm 458 */
				obj_t BgL_tbz00_1255;

				BgL_tbz00_1255 = BGL_THREAD_BACKEND();
				{	/* Llib/thread.scm 459 */
					bool_t BgL_test2675z00_5243;

					{	/* Llib/thread.scm 459 */
						obj_t BgL_classz00_2244;

						BgL_classz00_2244 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_1255))
							{	/* Llib/thread.scm 459 */
								BgL_objectz00_bglt BgL_arg1945z00_2246;

								BgL_arg1945z00_2246 = (BgL_objectz00_bglt) (BgL_tbz00_1255);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 459 */
										long BgL_idxz00_2252;

										BgL_idxz00_2252 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1945z00_2246);
										BgL_test2675z00_5243 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_2252 + 1L)) == BgL_classz00_2244);
									}
								else
									{	/* Llib/thread.scm 459 */
										bool_t BgL_res1961z00_2277;

										{	/* Llib/thread.scm 459 */
											obj_t BgL_oclassz00_2260;

											{	/* Llib/thread.scm 459 */
												obj_t BgL_arg1954z00_2268;
												long BgL_arg1955z00_2269;

												BgL_arg1954z00_2268 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 459 */
													long BgL_arg1956z00_2270;

													BgL_arg1956z00_2270 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1945z00_2246);
													BgL_arg1955z00_2269 =
														(BgL_arg1956z00_2270 - OBJECT_TYPE);
												}
												BgL_oclassz00_2260 =
													VECTOR_REF(BgL_arg1954z00_2268, BgL_arg1955z00_2269);
											}
											{	/* Llib/thread.scm 459 */
												bool_t BgL__ortest_1149z00_2261;

												BgL__ortest_1149z00_2261 =
													(BgL_classz00_2244 == BgL_oclassz00_2260);
												if (BgL__ortest_1149z00_2261)
													{	/* Llib/thread.scm 459 */
														BgL_res1961z00_2277 = BgL__ortest_1149z00_2261;
													}
												else
													{	/* Llib/thread.scm 459 */
														long BgL_odepthz00_2262;

														{	/* Llib/thread.scm 459 */
															obj_t BgL_arg1942z00_2263;

															BgL_arg1942z00_2263 = (BgL_oclassz00_2260);
															BgL_odepthz00_2262 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_2263);
														}
														if ((1L < BgL_odepthz00_2262))
															{	/* Llib/thread.scm 459 */
																obj_t BgL_arg1940z00_2265;

																{	/* Llib/thread.scm 459 */
																	obj_t BgL_arg1941z00_2266;

																	BgL_arg1941z00_2266 = (BgL_oclassz00_2260);
																	BgL_arg1940z00_2265 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_2266,
																		1L);
																}
																BgL_res1961z00_2277 =
																	(BgL_arg1940z00_2265 == BgL_classz00_2244);
															}
														else
															{	/* Llib/thread.scm 459 */
																BgL_res1961z00_2277 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2675z00_5243 = BgL_res1961z00_2277;
									}
							}
						else
							{	/* Llib/thread.scm 459 */
								BgL_test2675z00_5243 = ((bool_t) 0);
							}
					}
					if (BgL_test2675z00_5243)
						{	/* Llib/thread.scm 459 */
							return
								BGl_tbzd2currentzd2threadz00zz__threadz00(
								((BgL_threadzd2backendzd2_bglt) BgL_tbz00_1255));
						}
					else
						{	/* Llib/thread.scm 459 */
							return BFALSE;
						}
				}
			}
		}

	}



/* current-thread */
	BGL_EXPORTED_DEF obj_t BGl_currentzd2threadzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 465 */
			{	/* Llib/thread.scm 466 */
				obj_t BgL_thz00_1257;

				BgL_thz00_1257 = BGl_z52currentzd2threadz80zz__threadz00();
				{	/* Llib/thread.scm 467 */
					bool_t BgL_test2680z00_5269;

					{	/* Llib/thread.scm 467 */
						obj_t BgL_classz00_2278;

						BgL_classz00_2278 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_1257))
							{	/* Llib/thread.scm 467 */
								BgL_objectz00_bglt BgL_arg1945z00_2280;

								BgL_arg1945z00_2280 = (BgL_objectz00_bglt) (BgL_thz00_1257);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 467 */
										long BgL_idxz00_2286;

										BgL_idxz00_2286 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1945z00_2280);
										BgL_test2680z00_5269 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_2286 + 1L)) == BgL_classz00_2278);
									}
								else
									{	/* Llib/thread.scm 467 */
										bool_t BgL_res1962z00_2311;

										{	/* Llib/thread.scm 467 */
											obj_t BgL_oclassz00_2294;

											{	/* Llib/thread.scm 467 */
												obj_t BgL_arg1954z00_2302;
												long BgL_arg1955z00_2303;

												BgL_arg1954z00_2302 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 467 */
													long BgL_arg1956z00_2304;

													BgL_arg1956z00_2304 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1945z00_2280);
													BgL_arg1955z00_2303 =
														(BgL_arg1956z00_2304 - OBJECT_TYPE);
												}
												BgL_oclassz00_2294 =
													VECTOR_REF(BgL_arg1954z00_2302, BgL_arg1955z00_2303);
											}
											{	/* Llib/thread.scm 467 */
												bool_t BgL__ortest_1149z00_2295;

												BgL__ortest_1149z00_2295 =
													(BgL_classz00_2278 == BgL_oclassz00_2294);
												if (BgL__ortest_1149z00_2295)
													{	/* Llib/thread.scm 467 */
														BgL_res1962z00_2311 = BgL__ortest_1149z00_2295;
													}
												else
													{	/* Llib/thread.scm 467 */
														long BgL_odepthz00_2296;

														{	/* Llib/thread.scm 467 */
															obj_t BgL_arg1942z00_2297;

															BgL_arg1942z00_2297 = (BgL_oclassz00_2294);
															BgL_odepthz00_2296 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_2297);
														}
														if ((1L < BgL_odepthz00_2296))
															{	/* Llib/thread.scm 467 */
																obj_t BgL_arg1940z00_2299;

																{	/* Llib/thread.scm 467 */
																	obj_t BgL_arg1941z00_2300;

																	BgL_arg1941z00_2300 = (BgL_oclassz00_2294);
																	BgL_arg1940z00_2299 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_2300,
																		1L);
																}
																BgL_res1962z00_2311 =
																	(BgL_arg1940z00_2299 == BgL_classz00_2278);
															}
														else
															{	/* Llib/thread.scm 467 */
																BgL_res1962z00_2311 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2680z00_5269 = BgL_res1962z00_2311;
									}
							}
						else
							{	/* Llib/thread.scm 467 */
								BgL_test2680z00_5269 = ((bool_t) 0);
							}
					}
					if (BgL_test2680z00_5269)
						{	/* Llib/thread.scm 467 */
							return
								BGl_z52userzd2currentzd2threadz52zz__threadz00(
								((BgL_threadz00_bglt) BgL_thz00_1257));
						}
					else
						{	/* Llib/thread.scm 467 */
							return BFALSE;
						}
				}
			}
		}

	}



/* &current-thread */
	obj_t BGl_z62currentzd2threadzb0zz__threadz00(obj_t BgL_envz00_3509)
	{
		{	/* Llib/thread.scm 465 */
			return BGl_currentzd2threadzd2zz__threadz00();
		}

	}



/* thread-sleep! */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2sleepz12zc0zz__threadz00(obj_t
		BgL_objz00_51)
	{
		{	/* Llib/thread.scm 494 */
			{	/* Llib/thread.scm 495 */
				obj_t BgL_arg1341z00_4102;

				BgL_arg1341z00_4102 = BGl_currentzd2threadzd2zz__threadz00();
				return
					BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(
					((BgL_threadz00_bglt) BgL_arg1341z00_4102), BgL_objz00_51);
			}
		}

	}



/* &thread-sleep! */
	obj_t BGl_z62threadzd2sleepz12za2zz__threadz00(obj_t BgL_envz00_3510,
		obj_t BgL_objz00_3511)
	{
		{	/* Llib/thread.scm 494 */
			return BGl_threadzd2sleepz12zc0zz__threadz00(BgL_objz00_3511);
		}

	}



/* thread-yield! */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2yieldz12zc0zz__threadz00(void)
	{
		{	/* Llib/thread.scm 506 */
			{	/* Llib/thread.scm 507 */
				obj_t BgL_arg1342z00_4103;

				BgL_arg1342z00_4103 = BGl_currentzd2threadzd2zz__threadz00();
				return
					BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(
					((BgL_threadz00_bglt) BgL_arg1342z00_4103));
			}
		}

	}



/* &thread-yield! */
	obj_t BGl_z62threadzd2yieldz12za2zz__threadz00(obj_t BgL_envz00_3512)
	{
		{	/* Llib/thread.scm 506 */
			return BGl_threadzd2yieldz12zc0zz__threadz00();
		}

	}



/* thread-parameter */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2parameterzd2zz__threadz00(obj_t
		BgL_idz00_53)
	{
		{	/* Llib/thread.scm 512 */
			{	/* Llib/thread.scm 513 */
				obj_t BgL_cz00_2314;

				{	/* Llib/thread.scm 513 */
					obj_t BgL_arg1345z00_2315;

					BgL_arg1345z00_2315 = BGL_PARAMETERS();
					BgL_cz00_2314 =
						BGl_assqz00zz__r4_pairs_and_lists_6_3z00(BgL_idz00_53,
						BgL_arg1345z00_2315);
				}
				if (PAIRP(BgL_cz00_2314))
					{	/* Llib/thread.scm 514 */
						return CDR(BgL_cz00_2314);
					}
				else
					{	/* Llib/thread.scm 514 */
						return BFALSE;
					}
			}
		}

	}



/* &thread-parameter */
	obj_t BGl_z62threadzd2parameterzb0zz__threadz00(obj_t BgL_envz00_3513,
		obj_t BgL_idz00_3514)
	{
		{	/* Llib/thread.scm 512 */
			{	/* Llib/thread.scm 513 */
				obj_t BgL_auxz00_5308;

				if (SYMBOLP(BgL_idz00_3514))
					{	/* Llib/thread.scm 513 */
						BgL_auxz00_5308 = BgL_idz00_3514;
					}
				else
					{
						obj_t BgL_auxz00_5311;

						BgL_auxz00_5311 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(22199L), BGl_string2224z00zz__threadz00,
							BGl_string2225z00zz__threadz00, BgL_idz00_3514);
						FAILURE(BgL_auxz00_5311, BFALSE, BFALSE);
					}
				return BGl_threadzd2parameterzd2zz__threadz00(BgL_auxz00_5308);
			}
		}

	}



/* thread-parameter-set! */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2parameterzd2setz12z12zz__threadz00(obj_t
		BgL_idz00_54, obj_t BgL_valz00_55)
	{
		{	/* Llib/thread.scm 521 */
			{	/* Llib/thread.scm 522 */
				obj_t BgL_cz00_2318;

				{	/* Llib/thread.scm 522 */
					obj_t BgL_arg1352z00_2319;

					BgL_arg1352z00_2319 = BGL_PARAMETERS();
					BgL_cz00_2318 =
						BGl_assqz00zz__r4_pairs_and_lists_6_3z00(BgL_idz00_54,
						BgL_arg1352z00_2319);
				}
				if (PAIRP(BgL_cz00_2318))
					{	/* Llib/thread.scm 523 */
						return SET_CDR(BgL_cz00_2318, BgL_valz00_55);
					}
				else
					{	/* Llib/thread.scm 523 */
						{	/* Llib/thread.scm 527 */
							obj_t BgL_arg1347z00_2321;

							{	/* Llib/thread.scm 527 */
								obj_t BgL_arg1349z00_2322;
								obj_t BgL_arg1351z00_2323;

								BgL_arg1349z00_2322 =
									MAKE_YOUNG_PAIR(BgL_idz00_54, BgL_valz00_55);
								BgL_arg1351z00_2323 = BGL_PARAMETERS();
								BgL_arg1347z00_2321 =
									MAKE_YOUNG_PAIR(BgL_arg1349z00_2322, BgL_arg1351z00_2323);
							}
							BGL_PARAMETERS_SET(BgL_arg1347z00_2321);
						}
						return BgL_valz00_55;
					}
			}
		}

	}



/* &thread-parameter-set! */
	obj_t BGl_z62threadzd2parameterzd2setz12z70zz__threadz00(obj_t
		BgL_envz00_3515, obj_t BgL_idz00_3516, obj_t BgL_valz00_3517)
	{
		{	/* Llib/thread.scm 521 */
			{	/* Llib/thread.scm 522 */
				obj_t BgL_auxz00_5325;

				if (SYMBOLP(BgL_idz00_3516))
					{	/* Llib/thread.scm 522 */
						BgL_auxz00_5325 = BgL_idz00_3516;
					}
				else
					{
						obj_t BgL_auxz00_5328;

						BgL_auxz00_5328 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(22546L), BGl_string2226z00zz__threadz00,
							BGl_string2225z00zz__threadz00, BgL_idz00_3516);
						FAILURE(BgL_auxz00_5328, BFALSE, BFALSE);
					}
				return
					BGl_threadzd2parameterzd2setz12z12zz__threadz00(BgL_auxz00_5325,
					BgL_valz00_3517);
			}
		}

	}



/* mutex? */
	BGL_EXPORTED_DEF bool_t BGl_mutexzf3zf3zz__threadz00(obj_t BgL_objz00_73)
	{
		{	/* Llib/thread.scm 614 */
			return BGL_MUTEXP(BgL_objz00_73);
		}

	}



/* &mutex? */
	obj_t BGl_z62mutexzf3z91zz__threadz00(obj_t BgL_envz00_3518,
		obj_t BgL_objz00_3519)
	{
		{	/* Llib/thread.scm 614 */
			return BBOOL(BGl_mutexzf3zf3zz__threadz00(BgL_objz00_3519));
		}

	}



/* _make-mutex */
	obj_t BGl__makezd2mutexzd2zz__threadz00(obj_t BgL_env1256z00_76,
		obj_t BgL_opt1255z00_75)
	{
		{	/* Llib/thread.scm 620 */
			{	/* Llib/thread.scm 620 */

				{	/* Llib/thread.scm 620 */
					long BgL_aux1258z00_4104;

					{
						obj_t BgL_auxz00_5336;

						if (VECTORP(BgL_opt1255z00_75))
							{	/* Llib/thread.scm 620 */
								BgL_auxz00_5336 = BgL_opt1255z00_75;
							}
						else
							{
								obj_t BgL_auxz00_5339;

								BgL_auxz00_5339 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(27138L),
									BGl_string2227z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1255z00_75);
								FAILURE(BgL_auxz00_5339, BFALSE, BFALSE);
							}
						BgL_aux1258z00_4104 = VECTOR_LENGTH(BgL_auxz00_5336);
					}
					switch (BgL_aux1258z00_4104)
						{
						case 0L:

							{	/* Llib/thread.scm 620 */
								obj_t BgL_namez00_4105;

								BgL_namez00_4105 =
									BGl_gensymz00zz__r4_symbols_6_4z00
									(BGl_symbol2228z00zz__threadz00);
								{	/* Llib/thread.scm 620 */

									return bgl_make_mutex(BgL_namez00_4105);
								}
							}
							break;
						case 1L:

							{	/* Llib/thread.scm 620 */
								obj_t BgL_namez00_4106;

								{
									obj_t BgL_auxz00_5346;

									if (VECTORP(BgL_opt1255z00_75))
										{	/* Llib/thread.scm 620 */
											BgL_auxz00_5346 = BgL_opt1255z00_75;
										}
									else
										{
											obj_t BgL_auxz00_5349;

											BgL_auxz00_5349 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(27138L),
												BGl_string2227z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1255z00_75);
											FAILURE(BgL_auxz00_5349, BFALSE, BFALSE);
										}
									BgL_namez00_4106 = VECTOR_REF(BgL_auxz00_5346, 0L);
								}
								{	/* Llib/thread.scm 620 */

									return bgl_make_mutex(BgL_namez00_4106);
								}
							}
							break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* make-mutex */
	BGL_EXPORTED_DEF obj_t BGl_makezd2mutexzd2zz__threadz00(obj_t BgL_namez00_74)
	{
		{	/* Llib/thread.scm 620 */
			return bgl_make_mutex(BgL_namez00_74);
		}

	}



/* _make-spinlock */
	obj_t BGl__makezd2spinlockzd2zz__threadz00(obj_t BgL_env1260z00_79,
		obj_t BgL_opt1259z00_78)
	{
		{	/* Llib/thread.scm 626 */
			{	/* Llib/thread.scm 626 */

				{	/* Llib/thread.scm 626 */
					long BgL_aux1262z00_4107;

					{
						obj_t BgL_auxz00_5357;

						if (VECTORP(BgL_opt1259z00_78))
							{	/* Llib/thread.scm 626 */
								BgL_auxz00_5357 = BgL_opt1259z00_78;
							}
						else
							{
								obj_t BgL_auxz00_5360;

								BgL_auxz00_5360 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(27446L),
									BGl_string2230z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1259z00_78);
								FAILURE(BgL_auxz00_5360, BFALSE, BFALSE);
							}
						BgL_aux1262z00_4107 = VECTOR_LENGTH(BgL_auxz00_5357);
					}
					switch (BgL_aux1262z00_4107)
						{
						case 0L:

							{	/* Llib/thread.scm 626 */
								obj_t BgL_namez00_4108;

								BgL_namez00_4108 =
									BGl_gensymz00zz__r4_symbols_6_4z00
									(BGl_symbol2231z00zz__threadz00);
								{	/* Llib/thread.scm 626 */

									return bgl_make_spinlock(BgL_namez00_4108);
								}
							}
							break;
						case 1L:

							{	/* Llib/thread.scm 626 */
								obj_t BgL_namez00_4109;

								{
									obj_t BgL_auxz00_5367;

									if (VECTORP(BgL_opt1259z00_78))
										{	/* Llib/thread.scm 626 */
											BgL_auxz00_5367 = BgL_opt1259z00_78;
										}
									else
										{
											obj_t BgL_auxz00_5370;

											BgL_auxz00_5370 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(27446L),
												BGl_string2230z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1259z00_78);
											FAILURE(BgL_auxz00_5370, BFALSE, BFALSE);
										}
									BgL_namez00_4109 = VECTOR_REF(BgL_auxz00_5367, 0L);
								}
								{	/* Llib/thread.scm 626 */

									return bgl_make_spinlock(BgL_namez00_4109);
								}
							}
							break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* make-spinlock */
	BGL_EXPORTED_DEF obj_t BGl_makezd2spinlockzd2zz__threadz00(obj_t
		BgL_namez00_77)
	{
		{	/* Llib/thread.scm 626 */
			return bgl_make_spinlock(BgL_namez00_77);
		}

	}



/* mutex-nil */
	BGL_EXPORTED_DEF obj_t BGl_mutexzd2nilzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 633 */
			return BGl_za2mutexzd2nilza2zd2zz__threadz00;
		}

	}



/* &mutex-nil */
	obj_t BGl_z62mutexzd2nilzb0zz__threadz00(obj_t BgL_envz00_3520)
	{
		{	/* Llib/thread.scm 633 */
			return BGl_mutexzd2nilzd2zz__threadz00();
		}

	}



/* mutex-name */
	BGL_EXPORTED_DEF obj_t BGl_mutexzd2namezd2zz__threadz00(obj_t BgL_objz00_80)
	{
		{	/* Llib/thread.scm 638 */
			return BGL_MUTEX_NAME(BgL_objz00_80);
		}

	}



/* &mutex-name */
	obj_t BGl_z62mutexzd2namezb0zz__threadz00(obj_t BgL_envz00_3521,
		obj_t BgL_objz00_3522)
	{
		{	/* Llib/thread.scm 638 */
			{	/* Llib/thread.scm 639 */
				obj_t BgL_auxz00_5380;

				if (BGL_MUTEXP(BgL_objz00_3522))
					{	/* Llib/thread.scm 639 */
						BgL_auxz00_5380 = BgL_objz00_3522;
					}
				else
					{
						obj_t BgL_auxz00_5383;

						BgL_auxz00_5383 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(28093L), BGl_string2233z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_objz00_3522);
						FAILURE(BgL_auxz00_5383, BFALSE, BFALSE);
					}
				return BGl_mutexzd2namezd2zz__threadz00(BgL_auxz00_5380);
			}
		}

	}



/* _mutex-lock! */
	obj_t BGl__mutexzd2lockz12zc0zz__threadz00(obj_t BgL_env1264z00_84,
		obj_t BgL_opt1263z00_83)
	{
		{	/* Llib/thread.scm 644 */
			{	/* Llib/thread.scm 644 */
				obj_t BgL_g1265z00_4110;

				{
					obj_t BgL_auxz00_5388;

					if (VECTORP(BgL_opt1263z00_83))
						{	/* Llib/thread.scm 644 */
							BgL_auxz00_5388 = BgL_opt1263z00_83;
						}
					else
						{
							obj_t BgL_auxz00_5391;

							BgL_auxz00_5391 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(28335L), BGl_string2234z00zz__threadz00,
								BGl_string2220z00zz__threadz00, BgL_opt1263z00_83);
							FAILURE(BgL_auxz00_5391, BFALSE, BFALSE);
						}
					BgL_g1265z00_4110 = VECTOR_REF(BgL_auxz00_5388, 0L);
				}
				{	/* Llib/thread.scm 644 */
					long BgL_aux1267z00_4111;

					{
						obj_t BgL_auxz00_5396;

						if (VECTORP(BgL_opt1263z00_83))
							{	/* Llib/thread.scm 644 */
								BgL_auxz00_5396 = BgL_opt1263z00_83;
							}
						else
							{
								obj_t BgL_auxz00_5399;

								BgL_auxz00_5399 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(28335L),
									BGl_string2234z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1263z00_83);
								FAILURE(BgL_auxz00_5399, BFALSE, BFALSE);
							}
						BgL_aux1267z00_4111 = VECTOR_LENGTH(BgL_auxz00_5396);
					}
					switch (BgL_aux1267z00_4111)
						{
						case 1L:

							{	/* Llib/thread.scm 644 */

								{	/* Llib/thread.scm 644 */
									obj_t BgL_mz00_4112;

									if (BGL_MUTEXP(BgL_g1265z00_4110))
										{	/* Llib/thread.scm 644 */
											BgL_mz00_4112 = BgL_g1265z00_4110;
										}
									else
										{
											obj_t BgL_auxz00_5406;

											BgL_auxz00_5406 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(28335L),
												BGl_string2234z00zz__threadz00,
												BGl_string2229z00zz__threadz00, BgL_g1265z00_4110);
											FAILURE(BgL_auxz00_5406, BFALSE, BFALSE);
										}
									{	/* Llib/thread.scm 646 */
										int BgL_arg1355z00_4113;

										BgL_arg1355z00_4113 = BGL_MUTEX_LOCK(BgL_mz00_4112);
										return BBOOL(((long) (BgL_arg1355z00_4113) == 0L));
							}}} break;
						case 2L:

							{	/* Llib/thread.scm 644 */
								obj_t BgL_timeoutz00_4114;

								{
									obj_t BgL_auxz00_5414;

									if (VECTORP(BgL_opt1263z00_83))
										{	/* Llib/thread.scm 644 */
											BgL_auxz00_5414 = BgL_opt1263z00_83;
										}
									else
										{
											obj_t BgL_auxz00_5417;

											BgL_auxz00_5417 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(28335L),
												BGl_string2234z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1263z00_83);
											FAILURE(BgL_auxz00_5417, BFALSE, BFALSE);
										}
									BgL_timeoutz00_4114 = VECTOR_REF(BgL_auxz00_5414, 1L);
								}
								{	/* Llib/thread.scm 644 */

									{	/* Llib/thread.scm 644 */
										obj_t BgL_mz00_4115;
										long BgL_timeoutz00_4116;

										if (BGL_MUTEXP(BgL_g1265z00_4110))
											{	/* Llib/thread.scm 644 */
												BgL_mz00_4115 = BgL_g1265z00_4110;
											}
										else
											{
												obj_t BgL_auxz00_5424;

												BgL_auxz00_5424 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2213z00zz__threadz00, BINT(28335L),
													BGl_string2234z00zz__threadz00,
													BGl_string2229z00zz__threadz00, BgL_g1265z00_4110);
												FAILURE(BgL_auxz00_5424, BFALSE, BFALSE);
											}
										{	/* Llib/thread.scm 644 */
											obj_t BgL_tmpz00_5428;

											if (INTEGERP(BgL_timeoutz00_4114))
												{	/* Llib/thread.scm 644 */
													BgL_tmpz00_5428 = BgL_timeoutz00_4114;
												}
											else
												{
													obj_t BgL_auxz00_5431;

													BgL_auxz00_5431 =
														BGl_typezd2errorzd2zz__errorz00
														(BGl_string2213z00zz__threadz00, BINT(28335L),
														BGl_string2234z00zz__threadz00,
														BGl_string2235z00zz__threadz00,
														BgL_timeoutz00_4114);
													FAILURE(BgL_auxz00_5431, BFALSE, BFALSE);
												}
											BgL_timeoutz00_4116 = (long) CINT(BgL_tmpz00_5428);
										}
										if ((BgL_timeoutz00_4116 == 0L))
											{	/* Llib/thread.scm 646 */
												int BgL_arg1355z00_4117;

												BgL_arg1355z00_4117 = BGL_MUTEX_LOCK(BgL_mz00_4115);
												return BBOOL(((long) (BgL_arg1355z00_4117) == 0L));
											}
										else
											{	/* Llib/thread.scm 647 */
												int BgL_arg1356z00_4118;

												BgL_arg1356z00_4118 =
													BGL_MUTEX_TIMED_LOCK(BgL_mz00_4115,
													BgL_timeoutz00_4116);
												return BBOOL(((long) (BgL_arg1356z00_4118) == 0L));
							}}}} break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* mutex-lock! */
	BGL_EXPORTED_DEF obj_t BGl_mutexzd2lockz12zc0zz__threadz00(obj_t BgL_mz00_81,
		long BgL_timeoutz00_82)
	{
		{	/* Llib/thread.scm 644 */
			if ((BgL_timeoutz00_82 == 0L))
				{	/* Llib/thread.scm 646 */
					int BgL_arg1355z00_4119;

					BgL_arg1355z00_4119 = BGL_MUTEX_LOCK(BgL_mz00_81);
					return BBOOL(((long) (BgL_arg1355z00_4119) == 0L));
				}
			else
				{	/* Llib/thread.scm 647 */
					int BgL_arg1356z00_4120;

					BgL_arg1356z00_4120 =
						BGL_MUTEX_TIMED_LOCK(BgL_mz00_81, BgL_timeoutz00_82);
					return BBOOL(((long) (BgL_arg1356z00_4120) == 0L));
		}}

	}



/* mutex-unlock! */
	BGL_EXPORTED_DEF obj_t BGl_mutexzd2unlockz12zc0zz__threadz00(obj_t
		BgL_mz00_85)
	{
		{	/* Llib/thread.scm 652 */
			{	/* Llib/thread.scm 653 */
				int BgL_arg1357z00_4121;

				BgL_arg1357z00_4121 = BGL_MUTEX_UNLOCK(BgL_mz00_85);
				return BBOOL(((long) (BgL_arg1357z00_4121) == 0L));
		}}

	}



/* &mutex-unlock! */
	obj_t BGl_z62mutexzd2unlockz12za2zz__threadz00(obj_t BgL_envz00_3523,
		obj_t BgL_mz00_3524)
	{
		{	/* Llib/thread.scm 652 */
			{	/* Llib/thread.scm 653 */
				obj_t BgL_auxz00_5461;

				if (BGL_MUTEXP(BgL_mz00_3524))
					{	/* Llib/thread.scm 653 */
						BgL_auxz00_5461 = BgL_mz00_3524;
					}
				else
					{
						obj_t BgL_auxz00_5464;

						BgL_auxz00_5464 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(28760L), BGl_string2236z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_mz00_3524);
						FAILURE(BgL_auxz00_5464, BFALSE, BFALSE);
					}
				return BGl_mutexzd2unlockz12zc0zz__threadz00(BgL_auxz00_5461);
			}
		}

	}



/* mutex-state */
	BGL_EXPORTED_DEF obj_t BGl_mutexzd2statezd2zz__threadz00(obj_t
		BgL_mutexz00_86)
	{
		{	/* Llib/thread.scm 658 */
			return BGL_MUTEX_STATE(BgL_mutexz00_86);
		}

	}



/* &mutex-state */
	obj_t BGl_z62mutexzd2statezb0zz__threadz00(obj_t BgL_envz00_3525,
		obj_t BgL_mutexz00_3526)
	{
		{	/* Llib/thread.scm 658 */
			{	/* Llib/thread.scm 659 */
				obj_t BgL_auxz00_5470;

				if (BGL_MUTEXP(BgL_mutexz00_3526))
					{	/* Llib/thread.scm 659 */
						BgL_auxz00_5470 = BgL_mutexz00_3526;
					}
				else
					{
						obj_t BgL_auxz00_5473;

						BgL_auxz00_5473 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(29043L), BGl_string2237z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_mutexz00_3526);
						FAILURE(BgL_auxz00_5473, BFALSE, BFALSE);
					}
				return BGl_mutexzd2statezd2zz__threadz00(BgL_auxz00_5470);
			}
		}

	}



/* with-lock */
	BGL_EXPORTED_DEF obj_t BGl_withzd2lockzd2zz__threadz00(obj_t BgL_mutexz00_88,
		obj_t BgL_thunkz00_89)
	{
		{	/* Llib/thread.scm 670 */
			{	/* Llib/thread.scm 671 */
				obj_t BgL_top2705z00_5479;

				BgL_top2705z00_5479 = BGL_EXITD_TOP_AS_OBJ();
				BGL_MUTEX_LOCK(BgL_mutexz00_88);
				BGL_EXITD_PUSH_PROTECT(BgL_top2705z00_5479, BgL_mutexz00_88);
				BUNSPEC;
				{	/* Llib/thread.scm 671 */
					obj_t BgL_tmp2704z00_5478;

					BgL_tmp2704z00_5478 = BGL_PROCEDURE_CALL0(BgL_thunkz00_89);
					BGL_EXITD_POP_PROTECT(BgL_top2705z00_5479);
					BUNSPEC;
					BGL_MUTEX_UNLOCK(BgL_mutexz00_88);
					return BgL_tmp2704z00_5478;
				}
			}
		}

	}



/* &with-lock */
	obj_t BGl_z62withzd2lockzb0zz__threadz00(obj_t BgL_envz00_3527,
		obj_t BgL_mutexz00_3528, obj_t BgL_thunkz00_3529)
	{
		{	/* Llib/thread.scm 670 */
			{	/* Llib/thread.scm 671 */
				obj_t BgL_auxz00_5495;
				obj_t BgL_auxz00_5488;

				if (PROCEDUREP(BgL_thunkz00_3529))
					{	/* Llib/thread.scm 671 */
						BgL_auxz00_5495 = BgL_thunkz00_3529;
					}
				else
					{
						obj_t BgL_auxz00_5498;

						BgL_auxz00_5498 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(29606L), BGl_string2238z00zz__threadz00,
							BGl_string2223z00zz__threadz00, BgL_thunkz00_3529);
						FAILURE(BgL_auxz00_5498, BFALSE, BFALSE);
					}
				if (BGL_MUTEXP(BgL_mutexz00_3528))
					{	/* Llib/thread.scm 671 */
						BgL_auxz00_5488 = BgL_mutexz00_3528;
					}
				else
					{
						obj_t BgL_auxz00_5491;

						BgL_auxz00_5491 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(29606L), BGl_string2238z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_mutexz00_3528);
						FAILURE(BgL_auxz00_5491, BFALSE, BFALSE);
					}
				return
					BGl_withzd2lockzd2zz__threadz00(BgL_auxz00_5488, BgL_auxz00_5495);
			}
		}

	}



/* with-timed-lock */
	BGL_EXPORTED_DEF obj_t BGl_withzd2timedzd2lockz00zz__threadz00(obj_t
		BgL_mutexz00_90, int BgL_timeoutz00_91, obj_t BgL_thunkz00_92)
	{
		{	/* Llib/thread.scm 677 */
			{	/* Llib/thread.scm 678 */
				bool_t BgL_test2708z00_5503;

				{	/* Llib/thread.scm 678 */
					long BgL_timeoutz00_2367;

					BgL_timeoutz00_2367 = (long) (BgL_timeoutz00_91);
					if ((BgL_timeoutz00_2367 == 0L))
						{	/* Llib/thread.scm 646 */
							int BgL_arg1355z00_2369;

							BgL_arg1355z00_2369 = BGL_MUTEX_LOCK(BgL_mutexz00_90);
							BgL_test2708z00_5503 = ((long) (BgL_arg1355z00_2369) == 0L);
						}
					else
						{	/* Llib/thread.scm 647 */
							int BgL_arg1356z00_2370;

							BgL_arg1356z00_2370 =
								BGL_MUTEX_TIMED_LOCK(BgL_mutexz00_90, BgL_timeoutz00_2367);
							BgL_test2708z00_5503 = ((long) (BgL_arg1356z00_2370) == 0L);
				}}
				if (BgL_test2708z00_5503)
					{	/* Llib/thread.scm 679 */
						obj_t BgL_exitd1103z00_2363;

						BgL_exitd1103z00_2363 = BGL_EXITD_TOP_AS_OBJ();
						{	/* Llib/thread.scm 681 */
							obj_t BgL_zc3z04anonymousza31359ze3z87_3530;

							BgL_zc3z04anonymousza31359ze3z87_3530 =
								MAKE_FX_PROCEDURE
								(BGl_z62zc3z04anonymousza31359ze3ze5zz__threadz00, (int) (0L),
								(int) (1L));
							PROCEDURE_SET(BgL_zc3z04anonymousza31359ze3z87_3530, (int) (0L),
								BgL_mutexz00_90);
							{	/* Llib/thread.scm 679 */
								obj_t BgL_arg1934z00_2377;

								{	/* Llib/thread.scm 679 */
									obj_t BgL_arg1935z00_2378;

									BgL_arg1935z00_2378 =
										BGL_EXITD_PROTECT(BgL_exitd1103z00_2363);
									BgL_arg1934z00_2377 =
										MAKE_YOUNG_PAIR(BgL_zc3z04anonymousza31359ze3z87_3530,
										BgL_arg1935z00_2378);
								}
								BGL_EXITD_PROTECT_SET(BgL_exitd1103z00_2363,
									BgL_arg1934z00_2377);
								BUNSPEC;
							}
							{	/* Llib/thread.scm 680 */
								obj_t BgL_tmp1105z00_2365;

								BgL_tmp1105z00_2365 = BGL_PROCEDURE_CALL0(BgL_thunkz00_92);
								{	/* Llib/thread.scm 679 */
									bool_t BgL_test2710z00_5525;

									{	/* Llib/thread.scm 679 */
										obj_t BgL_arg1933z00_2380;

										BgL_arg1933z00_2380 =
											BGL_EXITD_PROTECT(BgL_exitd1103z00_2363);
										BgL_test2710z00_5525 = PAIRP(BgL_arg1933z00_2380);
									}
									if (BgL_test2710z00_5525)
										{	/* Llib/thread.scm 679 */
											obj_t BgL_arg1931z00_2381;

											{	/* Llib/thread.scm 679 */
												obj_t BgL_arg1932z00_2382;

												BgL_arg1932z00_2382 =
													BGL_EXITD_PROTECT(BgL_exitd1103z00_2363);
												BgL_arg1931z00_2381 =
													CDR(((obj_t) BgL_arg1932z00_2382));
											}
											BGL_EXITD_PROTECT_SET(BgL_exitd1103z00_2363,
												BgL_arg1931z00_2381);
											BUNSPEC;
										}
									else
										{	/* Llib/thread.scm 679 */
											BFALSE;
										}
								}
								{	/* Llib/thread.scm 653 */
									int BgL_arg1357z00_2385;

									BgL_arg1357z00_2385 = BGL_MUTEX_UNLOCK(BgL_mutexz00_90);
									((long) (BgL_arg1357z00_2385) == 0L);
								}
								return BgL_tmp1105z00_2365;
							}
						}
					}
				else
					{	/* Llib/thread.scm 678 */
						return BFALSE;
					}
			}
		}

	}



/* &with-timed-lock */
	obj_t BGl_z62withzd2timedzd2lockz62zz__threadz00(obj_t BgL_envz00_3531,
		obj_t BgL_mutexz00_3532, obj_t BgL_timeoutz00_3533, obj_t BgL_thunkz00_3534)
	{
		{	/* Llib/thread.scm 677 */
			{	/* Llib/thread.scm 678 */
				obj_t BgL_auxz00_5551;
				int BgL_auxz00_5542;
				obj_t BgL_auxz00_5535;

				if (PROCEDUREP(BgL_thunkz00_3534))
					{	/* Llib/thread.scm 678 */
						BgL_auxz00_5551 = BgL_thunkz00_3534;
					}
				else
					{
						obj_t BgL_auxz00_5554;

						BgL_auxz00_5554 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(29913L), BGl_string2239z00zz__threadz00,
							BGl_string2223z00zz__threadz00, BgL_thunkz00_3534);
						FAILURE(BgL_auxz00_5554, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 678 */
					obj_t BgL_tmpz00_5543;

					if (INTEGERP(BgL_timeoutz00_3533))
						{	/* Llib/thread.scm 678 */
							BgL_tmpz00_5543 = BgL_timeoutz00_3533;
						}
					else
						{
							obj_t BgL_auxz00_5546;

							BgL_auxz00_5546 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(29913L), BGl_string2239z00zz__threadz00,
								BGl_string2235z00zz__threadz00, BgL_timeoutz00_3533);
							FAILURE(BgL_auxz00_5546, BFALSE, BFALSE);
						}
					BgL_auxz00_5542 = CINT(BgL_tmpz00_5543);
				}
				if (BGL_MUTEXP(BgL_mutexz00_3532))
					{	/* Llib/thread.scm 678 */
						BgL_auxz00_5535 = BgL_mutexz00_3532;
					}
				else
					{
						obj_t BgL_auxz00_5538;

						BgL_auxz00_5538 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(29913L), BGl_string2239z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_mutexz00_3532);
						FAILURE(BgL_auxz00_5538, BFALSE, BFALSE);
					}
				return
					BGl_withzd2timedzd2lockz00zz__threadz00(BgL_auxz00_5535,
					BgL_auxz00_5542, BgL_auxz00_5551);
			}
		}

	}



/* &<@anonymous:1359> */
	obj_t BGl_z62zc3z04anonymousza31359ze3ze5zz__threadz00(obj_t BgL_envz00_3535)
	{
		{	/* Llib/thread.scm 679 */
			{	/* Llib/thread.scm 653 */
				obj_t BgL_mutexz00_3536;

				BgL_mutexz00_3536 =
					((obj_t) PROCEDURE_REF(BgL_envz00_3535, (int) (0L)));
				{	/* Llib/thread.scm 653 */
					bool_t BgL_tmpz00_5562;

					{	/* Llib/thread.scm 653 */
						int BgL_arg1357z00_4122;

						BgL_arg1357z00_4122 = BGL_MUTEX_UNLOCK(BgL_mutexz00_3536);
						BgL_tmpz00_5562 = ((long) (BgL_arg1357z00_4122) == 0L);
					}
					return BBOOL(BgL_tmpz00_5562);
				}
			}
		}

	}



/* condition-variable? */
	BGL_EXPORTED_DEF bool_t BGl_conditionzd2variablezf3z21zz__threadz00(obj_t
		BgL_objz00_93)
	{
		{	/* Llib/thread.scm 686 */
			return BGL_CONDVARP(BgL_objz00_93);
		}

	}



/* &condition-variable? */
	obj_t BGl_z62conditionzd2variablezf3z43zz__threadz00(obj_t BgL_envz00_3537,
		obj_t BgL_objz00_3538)
	{
		{	/* Llib/thread.scm 686 */
			return
				BBOOL(BGl_conditionzd2variablezf3z21zz__threadz00(BgL_objz00_3538));
		}

	}



/* _make-condition-variable */
	obj_t BGl__makezd2conditionzd2variablez00zz__threadz00(obj_t
		BgL_env1269z00_96, obj_t BgL_opt1268z00_95)
	{
		{	/* Llib/thread.scm 692 */
			{	/* Llib/thread.scm 692 */

				{	/* Llib/thread.scm 692 */
					long BgL_aux1271z00_4123;

					{
						obj_t BgL_auxz00_5570;

						if (VECTORP(BgL_opt1268z00_95))
							{	/* Llib/thread.scm 692 */
								BgL_auxz00_5570 = BgL_opt1268z00_95;
							}
						else
							{
								obj_t BgL_auxz00_5573;

								BgL_auxz00_5573 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(30513L),
									BGl_string2240z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1268z00_95);
								FAILURE(BgL_auxz00_5573, BFALSE, BFALSE);
							}
						BgL_aux1271z00_4123 = VECTOR_LENGTH(BgL_auxz00_5570);
					}
					switch (BgL_aux1271z00_4123)
						{
						case 0L:

							{	/* Llib/thread.scm 693 */
								obj_t BgL_namez00_4124;

								BgL_namez00_4124 =
									BGl_gensymz00zz__r4_symbols_6_4z00
									(BGl_symbol2241z00zz__threadz00);
								{	/* Llib/thread.scm 692 */

									return bgl_make_condvar(BgL_namez00_4124);
								}
							}
							break;
						case 1L:

							{	/* Llib/thread.scm 692 */
								obj_t BgL_namez00_4125;

								{
									obj_t BgL_auxz00_5580;

									if (VECTORP(BgL_opt1268z00_95))
										{	/* Llib/thread.scm 692 */
											BgL_auxz00_5580 = BgL_opt1268z00_95;
										}
									else
										{
											obj_t BgL_auxz00_5583;

											BgL_auxz00_5583 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(30513L),
												BGl_string2240z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1268z00_95);
											FAILURE(BgL_auxz00_5583, BFALSE, BFALSE);
										}
									BgL_namez00_4125 = VECTOR_REF(BgL_auxz00_5580, 0L);
								}
								{	/* Llib/thread.scm 692 */

									return bgl_make_condvar(BgL_namez00_4125);
								}
							}
							break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* make-condition-variable */
	BGL_EXPORTED_DEF obj_t BGl_makezd2conditionzd2variablez00zz__threadz00(obj_t
		BgL_namez00_94)
	{
		{	/* Llib/thread.scm 692 */
			return bgl_make_condvar(BgL_namez00_94);
		}

	}



/* condition-variable-nil */
	BGL_EXPORTED_DEF obj_t BGl_conditionzd2variablezd2nilz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 700 */
			return BGl_za2conditionzd2variablezd2nilza2z00zz__threadz00;
		}

	}



/* &condition-variable-nil */
	obj_t BGl_z62conditionzd2variablezd2nilz62zz__threadz00(obj_t BgL_envz00_3539)
	{
		{	/* Llib/thread.scm 700 */
			return BGl_conditionzd2variablezd2nilz00zz__threadz00();
		}

	}



/* condition-variable-name */
	BGL_EXPORTED_DEF obj_t BGl_conditionzd2variablezd2namez00zz__threadz00(obj_t
		BgL_objz00_97)
	{
		{	/* Llib/thread.scm 705 */
			return BGL_CONDVAR_NAME(BgL_objz00_97);
		}

	}



/* &condition-variable-name */
	obj_t BGl_z62conditionzd2variablezd2namez62zz__threadz00(obj_t
		BgL_envz00_3540, obj_t BgL_objz00_3541)
	{
		{	/* Llib/thread.scm 705 */
			{	/* Llib/thread.scm 706 */
				obj_t BgL_auxz00_5593;

				if (BGL_CONDVARP(BgL_objz00_3541))
					{	/* Llib/thread.scm 706 */
						BgL_auxz00_5593 = BgL_objz00_3541;
					}
				else
					{
						obj_t BgL_auxz00_5596;

						BgL_auxz00_5596 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(31238L), BGl_string2243z00zz__threadz00,
							BGl_string2244z00zz__threadz00, BgL_objz00_3541);
						FAILURE(BgL_auxz00_5596, BFALSE, BFALSE);
					}
				return BGl_conditionzd2variablezd2namez00zz__threadz00(BgL_auxz00_5593);
			}
		}

	}



/* _condition-variable-wait! */
	obj_t BGl__conditionzd2variablezd2waitz12z12zz__threadz00(obj_t
		BgL_env1273z00_102, obj_t BgL_opt1272z00_101)
	{
		{	/* Llib/thread.scm 711 */
			{	/* Llib/thread.scm 711 */
				obj_t BgL_g1274z00_4126;
				obj_t BgL_g1275z00_4127;

				{
					obj_t BgL_auxz00_5601;

					if (VECTORP(BgL_opt1272z00_101))
						{	/* Llib/thread.scm 711 */
							BgL_auxz00_5601 = BgL_opt1272z00_101;
						}
					else
						{
							obj_t BgL_auxz00_5604;

							BgL_auxz00_5604 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(31482L), BGl_string2245z00zz__threadz00,
								BGl_string2220z00zz__threadz00, BgL_opt1272z00_101);
							FAILURE(BgL_auxz00_5604, BFALSE, BFALSE);
						}
					BgL_g1274z00_4126 = VECTOR_REF(BgL_auxz00_5601, 0L);
				}
				{
					obj_t BgL_auxz00_5609;

					if (VECTORP(BgL_opt1272z00_101))
						{	/* Llib/thread.scm 711 */
							BgL_auxz00_5609 = BgL_opt1272z00_101;
						}
					else
						{
							obj_t BgL_auxz00_5612;

							BgL_auxz00_5612 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(31482L), BGl_string2245z00zz__threadz00,
								BGl_string2220z00zz__threadz00, BgL_opt1272z00_101);
							FAILURE(BgL_auxz00_5612, BFALSE, BFALSE);
						}
					BgL_g1275z00_4127 = VECTOR_REF(BgL_auxz00_5609, 1L);
				}
				{	/* Llib/thread.scm 711 */
					long BgL_aux1277z00_4128;

					{
						obj_t BgL_auxz00_5617;

						if (VECTORP(BgL_opt1272z00_101))
							{	/* Llib/thread.scm 711 */
								BgL_auxz00_5617 = BgL_opt1272z00_101;
							}
						else
							{
								obj_t BgL_auxz00_5620;

								BgL_auxz00_5620 =
									BGl_typezd2errorzd2zz__errorz00
									(BGl_string2213z00zz__threadz00, BINT(31482L),
									BGl_string2245z00zz__threadz00,
									BGl_string2220z00zz__threadz00, BgL_opt1272z00_101);
								FAILURE(BgL_auxz00_5620, BFALSE, BFALSE);
							}
						BgL_aux1277z00_4128 = VECTOR_LENGTH(BgL_auxz00_5617);
					}
					switch (BgL_aux1277z00_4128)
						{
						case 2L:

							{	/* Llib/thread.scm 711 */

								{	/* Llib/thread.scm 711 */
									obj_t BgL_cz00_4129;
									obj_t BgL_mz00_4130;

									if (BGL_CONDVARP(BgL_g1274z00_4126))
										{	/* Llib/thread.scm 711 */
											BgL_cz00_4129 = BgL_g1274z00_4126;
										}
									else
										{
											obj_t BgL_auxz00_5627;

											BgL_auxz00_5627 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(31482L),
												BGl_string2245z00zz__threadz00,
												BGl_string2244z00zz__threadz00, BgL_g1274z00_4126);
											FAILURE(BgL_auxz00_5627, BFALSE, BFALSE);
										}
									if (BGL_MUTEXP(BgL_g1275z00_4127))
										{	/* Llib/thread.scm 711 */
											BgL_mz00_4130 = BgL_g1275z00_4127;
										}
									else
										{
											obj_t BgL_auxz00_5633;

											BgL_auxz00_5633 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(31482L),
												BGl_string2245z00zz__threadz00,
												BGl_string2229z00zz__threadz00, BgL_g1275z00_4127);
											FAILURE(BgL_auxz00_5633, BFALSE, BFALSE);
										}
									return BBOOL(BGL_CONDVAR_WAIT(BgL_cz00_4129, BgL_mz00_4130));
								}
							}
							break;
						case 3L:

							{	/* Llib/thread.scm 711 */
								obj_t BgL_timeoutz00_4131;

								{
									obj_t BgL_auxz00_5639;

									if (VECTORP(BgL_opt1272z00_101))
										{	/* Llib/thread.scm 711 */
											BgL_auxz00_5639 = BgL_opt1272z00_101;
										}
									else
										{
											obj_t BgL_auxz00_5642;

											BgL_auxz00_5642 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2213z00zz__threadz00, BINT(31482L),
												BGl_string2245z00zz__threadz00,
												BGl_string2220z00zz__threadz00, BgL_opt1272z00_101);
											FAILURE(BgL_auxz00_5642, BFALSE, BFALSE);
										}
									BgL_timeoutz00_4131 = VECTOR_REF(BgL_auxz00_5639, 2L);
								}
								{	/* Llib/thread.scm 711 */

									{	/* Llib/thread.scm 711 */
										obj_t BgL_cz00_4132;
										obj_t BgL_mz00_4133;
										long BgL_timeoutz00_4134;

										if (BGL_CONDVARP(BgL_g1274z00_4126))
											{	/* Llib/thread.scm 711 */
												BgL_cz00_4132 = BgL_g1274z00_4126;
											}
										else
											{
												obj_t BgL_auxz00_5649;

												BgL_auxz00_5649 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2213z00zz__threadz00, BINT(31482L),
													BGl_string2245z00zz__threadz00,
													BGl_string2244z00zz__threadz00, BgL_g1274z00_4126);
												FAILURE(BgL_auxz00_5649, BFALSE, BFALSE);
											}
										if (BGL_MUTEXP(BgL_g1275z00_4127))
											{	/* Llib/thread.scm 711 */
												BgL_mz00_4133 = BgL_g1275z00_4127;
											}
										else
											{
												obj_t BgL_auxz00_5655;

												BgL_auxz00_5655 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2213z00zz__threadz00, BINT(31482L),
													BGl_string2245z00zz__threadz00,
													BGl_string2229z00zz__threadz00, BgL_g1275z00_4127);
												FAILURE(BgL_auxz00_5655, BFALSE, BFALSE);
											}
										{	/* Llib/thread.scm 711 */
											obj_t BgL_tmpz00_5659;

											if (INTEGERP(BgL_timeoutz00_4131))
												{	/* Llib/thread.scm 711 */
													BgL_tmpz00_5659 = BgL_timeoutz00_4131;
												}
											else
												{
													obj_t BgL_auxz00_5662;

													BgL_auxz00_5662 =
														BGl_typezd2errorzd2zz__errorz00
														(BGl_string2213z00zz__threadz00, BINT(31482L),
														BGl_string2245z00zz__threadz00,
														BGl_string2235z00zz__threadz00,
														BgL_timeoutz00_4131);
													FAILURE(BgL_auxz00_5662, BFALSE, BFALSE);
												}
											BgL_timeoutz00_4134 = (long) CINT(BgL_tmpz00_5659);
										}
										if ((BgL_timeoutz00_4134 == 0L))
											{	/* Llib/thread.scm 712 */
												return
													BBOOL(BGL_CONDVAR_WAIT(BgL_cz00_4132, BgL_mz00_4133));
											}
										else
											{	/* Llib/thread.scm 712 */
												return
													BBOOL(BGL_CONDVAR_TIMED_WAIT(BgL_cz00_4132,
														BgL_mz00_4133, BgL_timeoutz00_4134));
											}
									}
								}
							}
							break;
						default:
							return BUNSPEC;
						}
				}
			}
		}

	}



/* condition-variable-wait! */
	BGL_EXPORTED_DEF bool_t
		BGl_conditionzd2variablezd2waitz12z12zz__threadz00(obj_t BgL_cz00_98,
		obj_t BgL_mz00_99, long BgL_timeoutz00_100)
	{
		{	/* Llib/thread.scm 711 */
			if ((BgL_timeoutz00_100 == 0L))
				{	/* Llib/thread.scm 712 */
					return BGL_CONDVAR_WAIT(BgL_cz00_98, BgL_mz00_99);
				}
			else
				{	/* Llib/thread.scm 712 */
					return
						BGL_CONDVAR_TIMED_WAIT(BgL_cz00_98, BgL_mz00_99,
						BgL_timeoutz00_100);
				}
		}

	}



/* condition-variable-signal! */
	BGL_EXPORTED_DEF bool_t
		BGl_conditionzd2variablezd2signalz12z12zz__threadz00(obj_t BgL_cz00_103)
	{
		{	/* Llib/thread.scm 719 */
			return BGL_CONDVAR_SIGNAL(BgL_cz00_103);
		}

	}



/* &condition-variable-signal! */
	obj_t BGl_z62conditionzd2variablezd2signalz12z70zz__threadz00(obj_t
		BgL_envz00_3542, obj_t BgL_cz00_3543)
	{
		{	/* Llib/thread.scm 719 */
			{	/* Llib/thread.scm 720 */
				bool_t BgL_tmpz00_5679;

				{	/* Llib/thread.scm 720 */
					obj_t BgL_auxz00_5680;

					if (BGL_CONDVARP(BgL_cz00_3543))
						{	/* Llib/thread.scm 720 */
							BgL_auxz00_5680 = BgL_cz00_3543;
						}
					else
						{
							obj_t BgL_auxz00_5683;

							BgL_auxz00_5683 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(31924L), BGl_string2246z00zz__threadz00,
								BGl_string2244z00zz__threadz00, BgL_cz00_3543);
							FAILURE(BgL_auxz00_5683, BFALSE, BFALSE);
						}
					BgL_tmpz00_5679 =
						BGl_conditionzd2variablezd2signalz12z12zz__threadz00
						(BgL_auxz00_5680);
				}
				return BBOOL(BgL_tmpz00_5679);
			}
		}

	}



/* condition-variable-broadcast! */
	BGL_EXPORTED_DEF bool_t
		BGl_conditionzd2variablezd2broadcastz12z12zz__threadz00(obj_t BgL_cz00_104)
	{
		{	/* Llib/thread.scm 725 */
			return BGL_CONDVAR_BROADCAST(BgL_cz00_104);
		}

	}



/* &condition-variable-broadcast! */
	obj_t BGl_z62conditionzd2variablezd2broadcastz12z70zz__threadz00(obj_t
		BgL_envz00_3544, obj_t BgL_cz00_3545)
	{
		{	/* Llib/thread.scm 725 */
			{	/* Llib/thread.scm 726 */
				bool_t BgL_tmpz00_5690;

				{	/* Llib/thread.scm 726 */
					obj_t BgL_auxz00_5691;

					if (BGL_CONDVARP(BgL_cz00_3545))
						{	/* Llib/thread.scm 726 */
							BgL_auxz00_5691 = BgL_cz00_3545;
						}
					else
						{
							obj_t BgL_auxz00_5694;

							BgL_auxz00_5694 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(32221L), BGl_string2247z00zz__threadz00,
								BGl_string2244z00zz__threadz00, BgL_cz00_3545);
							FAILURE(BgL_auxz00_5694, BFALSE, BFALSE);
						}
					BgL_tmpz00_5690 =
						BGl_conditionzd2variablezd2broadcastz12z12zz__threadz00
						(BgL_auxz00_5691);
				}
				return BBOOL(BgL_tmpz00_5690);
			}
		}

	}



/* object-init */
	obj_t BGl_objectzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			{	/* Llib/thread.scm 161 */
				obj_t BgL_arg1364z00_1307;
				obj_t BgL_arg1365z00_1308;

				{	/* Llib/thread.scm 161 */
					obj_t BgL_v1161z00_1319;

					BgL_v1161z00_1319 = create_vector(1L);
					VECTOR_SET(BgL_v1161z00_1319, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2250z00zz__threadz00, BGl_proc2249z00zz__threadz00,
							BGl_proc2248z00zz__threadz00, ((bool_t) 1), ((bool_t) 0), BFALSE,
							BFALSE, BGl_symbol2252z00zz__threadz00));
					BgL_arg1364z00_1307 = BgL_v1161z00_1319;
				}
				{	/* Llib/thread.scm 161 */
					obj_t BgL_v1162z00_1330;

					BgL_v1162z00_1330 = create_vector(0L);
					BgL_arg1365z00_1308 = BgL_v1162z00_1330;
				}
				BGl_threadzd2backendzd2zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2256z00zz__threadz00, BGl_symbol2257z00zz__threadz00,
					BGl_objectz00zz__objectz00, 20365L, BGl_proc2255z00zz__threadz00,
					BGl_proc2254z00zz__threadz00, BFALSE, BGl_proc2253z00zz__threadz00,
					BFALSE, BgL_arg1364z00_1307, BgL_arg1365z00_1308);
			}
			{	/* Llib/thread.scm 164 */
				obj_t BgL_arg1378z00_1336;
				obj_t BgL_arg1379z00_1337;

				{	/* Llib/thread.scm 164 */
					obj_t BgL_v1163z00_1343;

					BgL_v1163z00_1343 = create_vector(3L);
					VECTOR_SET(BgL_v1163z00_1343, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2250z00zz__threadz00, BGl_proc2261z00zz__threadz00,
							BGl_proc2260z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2259z00zz__threadz00, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1163z00_1343, 1L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2266z00zz__threadz00, BGl_proc2265z00zz__threadz00,
							BGl_proc2264z00zz__threadz00, ((bool_t) 0), ((bool_t) 1), BFALSE,
							BFALSE, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1163z00_1343, 2L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2270z00zz__threadz00, BGl_proc2269z00zz__threadz00,
							BGl_proc2268z00zz__threadz00, ((bool_t) 0), ((bool_t) 1), BFALSE,
							BFALSE, BGl_symbol2262z00zz__threadz00));
					BgL_arg1378z00_1336 = BgL_v1163z00_1343;
				}
				{	/* Llib/thread.scm 164 */
					obj_t BgL_v1164z00_1377;

					BgL_v1164z00_1377 = create_vector(2L);
					{	/* Llib/thread.scm 167 */
						obj_t BgL_arg1400z00_1378;

						{	/* Llib/thread.scm 167 */
							obj_t BgL_arg1401z00_1379;

							BgL_arg1401z00_1379 =
								MAKE_YOUNG_PAIR(BGl_proc2272z00zz__threadz00,
								BGl_proc2273z00zz__threadz00);
							BgL_arg1400z00_1378 =
								MAKE_YOUNG_PAIR(BINT(0L), BgL_arg1401z00_1379);
						}
						VECTOR_SET(BgL_v1164z00_1377, 0L, BgL_arg1400z00_1378);
					}
					{	/* Llib/thread.scm 168 */
						obj_t BgL_arg1408z00_1395;

						{	/* Llib/thread.scm 168 */
							obj_t BgL_arg1409z00_1396;

							BgL_arg1409z00_1396 =
								MAKE_YOUNG_PAIR(BGl_proc2274z00zz__threadz00,
								BGl_proc2275z00zz__threadz00);
							BgL_arg1408z00_1395 =
								MAKE_YOUNG_PAIR(BINT(1L), BgL_arg1409z00_1396);
						}
						VECTOR_SET(BgL_v1164z00_1377, 1L, BgL_arg1408z00_1395);
					}
					BgL_arg1379z00_1337 = BgL_v1164z00_1377;
				}
				BGl_threadz00zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2221z00zz__threadz00, BGl_symbol2257z00zz__threadz00,
					BGl_objectz00zz__objectz00, 35587L, BFALSE,
					BGl_proc2277z00zz__threadz00,
					BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
					BGl_proc2276z00zz__threadz00, BFALSE, BgL_arg1378z00_1336,
					BgL_arg1379z00_1337);
			}
			{	/* Llib/thread.scm 170 */
				obj_t BgL_arg1420z00_1417;
				obj_t BgL_arg1421z00_1418;

				{	/* Llib/thread.scm 170 */
					obj_t BgL_v1165z00_1436;

					BgL_v1165z00_1436 = create_vector(6L);
					VECTOR_SET(BgL_v1165z00_1436, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2280z00zz__threadz00, BGl_proc2279z00zz__threadz00,
							BGl_proc2278z00zz__threadz00, ((bool_t) 1), ((bool_t) 0), BFALSE,
							BFALSE, BGl_symbol2282z00zz__threadz00));
					VECTOR_SET(BgL_v1165z00_1436, 1L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2286z00zz__threadz00, BGl_proc2285z00zz__threadz00,
							BGl_proc2284z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2283z00zz__threadz00, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1165z00_1436, 2L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2291z00zz__threadz00, BGl_proc2290z00zz__threadz00,
							BGl_proc2289z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2288z00zz__threadz00, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1165z00_1436, 3L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2296z00zz__threadz00, BGl_proc2295z00zz__threadz00,
							BGl_proc2294z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2293z00zz__threadz00, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1165z00_1436, 4L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2301z00zz__threadz00, BGl_proc2300z00zz__threadz00,
							BGl_proc2299z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2298z00zz__threadz00, BGl_symbol2262z00zz__threadz00));
					VECTOR_SET(BgL_v1165z00_1436, 5L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2306z00zz__threadz00, BGl_proc2305z00zz__threadz00,
							BGl_proc2304z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2303z00zz__threadz00, BGl_symbol2252z00zz__threadz00));
					BgL_arg1420z00_1417 = BgL_v1165z00_1436;
				}
				{	/* Llib/thread.scm 170 */
					obj_t BgL_v1166z00_1512;

					BgL_v1166z00_1512 = create_vector(0L);
					BgL_arg1421z00_1418 = BgL_v1166z00_1512;
				}
				BGl_nothreadz00zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2311z00zz__threadz00, BGl_symbol2257z00zz__threadz00,
					BGl_threadz00zz__threadz00, 50609L, BGl_proc2310z00zz__threadz00,
					BGl_proc2309z00zz__threadz00,
					BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
					BGl_proc2308z00zz__threadz00, BFALSE, BgL_arg1420z00_1417,
					BgL_arg1421z00_1418);
			}
			{	/* Llib/thread.scm 159 */
				obj_t BgL_arg1474z00_1519;
				obj_t BgL_arg1475z00_1520;

				{	/* Llib/thread.scm 159 */
					obj_t BgL_v1167z00_1531;

					BgL_v1167z00_1531 = create_vector(0L);
					BgL_arg1474z00_1519 = BgL_v1167z00_1531;
				}
				{	/* Llib/thread.scm 159 */
					obj_t BgL_v1168z00_1532;

					BgL_v1168z00_1532 = create_vector(0L);
					BgL_arg1475z00_1520 = BgL_v1168z00_1532;
				}
				return (BGl_nothreadzd2backendzd2zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2315z00zz__threadz00, BGl_symbol2257z00zz__threadz00,
						BGl_threadzd2backendzd2zz__threadz00, 1284L,
						BGl_proc2314z00zz__threadz00, BGl_proc2313z00zz__threadz00, BFALSE,
						BGl_proc2312z00zz__threadz00, BFALSE, BgL_arg1474z00_1519,
						BgL_arg1475z00_1520), BUNSPEC);
			}
		}

	}



/* &<@anonymous:1482> */
	obj_t BGl_z62zc3z04anonymousza31482ze3ze5zz__threadz00(obj_t BgL_envz00_3590,
		obj_t BgL_new1056z00_3591)
	{
		{	/* Llib/thread.scm 159 */
			{
				BgL_nothreadzd2backendzd2_bglt BgL_auxz00_5740;

				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt)
									((BgL_nothreadzd2backendzd2_bglt) BgL_new1056z00_3591))))->
						BgL_namez00) = ((obj_t) BGl_string2317z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5740 =
					((BgL_nothreadzd2backendzd2_bglt) BgL_new1056z00_3591);
				return ((obj_t) BgL_auxz00_5740);
			}
		}

	}



/* &lambda1480 */
	BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1480z62zz__threadz00(obj_t
		BgL_envz00_3592)
	{
		{	/* Llib/thread.scm 159 */
			{	/* Llib/thread.scm 159 */
				BgL_nothreadzd2backendzd2_bglt BgL_new1055z00_4136;

				BgL_new1055z00_4136 =
					((BgL_nothreadzd2backendzd2_bglt) BOBJECT(GC_MALLOC(sizeof(struct
								BgL_nothreadzd2backendzd2_bgl))));
				{	/* Llib/thread.scm 159 */
					long BgL_arg1481z00_4137;

					BgL_arg1481z00_4137 =
						BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1055z00_4136), BgL_arg1481z00_4137);
				}
				return BgL_new1055z00_4136;
			}
		}

	}



/* &lambda1476 */
	BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1476z62zz__threadz00(obj_t
		BgL_envz00_3593, obj_t BgL_name1054z00_3594)
	{
		{	/* Llib/thread.scm 159 */
			{	/* Llib/thread.scm 159 */
				BgL_nothreadzd2backendzd2_bglt BgL_new1120z00_4139;

				{	/* Llib/thread.scm 159 */
					BgL_nothreadzd2backendzd2_bglt BgL_new1118z00_4140;

					BgL_new1118z00_4140 =
						((BgL_nothreadzd2backendzd2_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_nothreadzd2backendzd2_bgl))));
					{	/* Llib/thread.scm 159 */
						long BgL_arg1479z00_4141;

						BgL_arg1479z00_4141 =
							BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1118z00_4140), BgL_arg1479z00_4141);
					}
					BgL_new1120z00_4139 = BgL_new1118z00_4140;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1120z00_4139)))->
						BgL_namez00) = ((obj_t) ((obj_t) BgL_name1054z00_3594)), BUNSPEC);
				return BgL_new1120z00_4139;
			}
		}

	}



/* &<@anonymous:1427> */
	obj_t BGl_z62zc3z04anonymousza31427ze3ze5zz__threadz00(obj_t BgL_envz00_3595,
		obj_t BgL_new1052z00_3596)
	{
		{	/* Llib/thread.scm 170 */
			{
				BgL_nothreadz00_bglt BgL_auxz00_5757;

				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt)
									((BgL_nothreadz00_bglt) BgL_new1052z00_3596))))->
						BgL_namez00) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_bodyz00) =
					((obj_t) BGl_conszd2envzd2zz__r4_pairs_and_lists_6_3z00), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_z52specificz52) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_z52cleanupz52) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_endzd2resultzd2) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_endzd2exceptionzd2) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3596)))->BgL_z52namez52) =
					((obj_t) BGl_string2317z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5757 = ((BgL_nothreadz00_bglt) BgL_new1052z00_3596);
				return ((obj_t) BgL_auxz00_5757);
			}
		}

	}



/* &lambda1425 */
	BgL_nothreadz00_bglt BGl_z62lambda1425z62zz__threadz00(obj_t BgL_envz00_3597)
	{
		{	/* Llib/thread.scm 170 */
			{	/* Llib/thread.scm 170 */
				BgL_nothreadz00_bglt BgL_new1051z00_4143;

				BgL_new1051z00_4143 =
					((BgL_nothreadz00_bglt) BOBJECT(GC_MALLOC(sizeof(struct
								BgL_nothreadz00_bgl))));
				{	/* Llib/thread.scm 170 */
					long BgL_arg1426z00_4144;

					BgL_arg1426z00_4144 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1051z00_4143), BgL_arg1426z00_4144);
				}
				return BgL_new1051z00_4143;
			}
		}

	}



/* &lambda1422 */
	BgL_nothreadz00_bglt BGl_z62lambda1422z62zz__threadz00(obj_t BgL_envz00_3598,
		obj_t BgL_name1044z00_3599, obj_t BgL_body1045z00_3600,
		obj_t BgL_z52specific1046z52_3601, obj_t BgL_z52cleanup1047z52_3602,
		obj_t BgL_endzd2result1048zd2_3603, obj_t BgL_endzd2exception1049zd2_3604,
		obj_t BgL_z52name1050z52_3605)
	{
		{	/* Llib/thread.scm 170 */
			{	/* Llib/thread.scm 170 */
				BgL_nothreadz00_bglt BgL_new1117z00_4147;

				{	/* Llib/thread.scm 170 */
					BgL_nothreadz00_bglt BgL_new1116z00_4148;

					BgL_new1116z00_4148 =
						((BgL_nothreadz00_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_nothreadz00_bgl))));
					{	/* Llib/thread.scm 170 */
						long BgL_arg1424z00_4149;

						BgL_arg1424z00_4149 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1116z00_4148), BgL_arg1424z00_4149);
					}
					BgL_new1117z00_4147 = BgL_new1116z00_4148;
				}
				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1117z00_4147)))->BgL_namez00) =
					((obj_t) BgL_name1044z00_3599), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->BgL_bodyz00) =
					((obj_t) ((obj_t) BgL_body1045z00_3600)), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->
						BgL_z52specificz52) =
					((obj_t) BgL_z52specific1046z52_3601), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->
						BgL_z52cleanupz52) = ((obj_t) BgL_z52cleanup1047z52_3602), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->
						BgL_endzd2resultzd2) =
					((obj_t) BgL_endzd2result1048zd2_3603), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->
						BgL_endzd2exceptionzd2) =
					((obj_t) BgL_endzd2exception1049zd2_3604), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1117z00_4147))->
						BgL_z52namez52) =
					((obj_t) ((obj_t) BgL_z52name1050z52_3605)), BUNSPEC);
				{	/* Llib/thread.scm 170 */
					obj_t BgL_fun1423z00_4150;

					BgL_fun1423z00_4150 =
						BGl_classzd2constructorzd2zz__objectz00
						(BGl_nothreadz00zz__threadz00);
					BGL_PROCEDURE_CALL1(BgL_fun1423z00_4150,
						((obj_t) BgL_new1117z00_4147));
				}
				return BgL_new1117z00_4147;
			}
		}

	}



/* &<@anonymous:1470> */
	obj_t BGl_z62zc3z04anonymousza31470ze3ze5zz__threadz00(obj_t BgL_envz00_3606)
	{
		{	/* Llib/thread.scm 170 */
			return BGl_string2318z00zz__threadz00;
		}

	}



/* &lambda1469 */
	obj_t BGl_z62lambda1469z62zz__threadz00(obj_t BgL_envz00_3607,
		obj_t BgL_oz00_3608, obj_t BgL_vz00_3609)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3608)))->BgL_z52namez52) =
				((obj_t) ((obj_t) BgL_vz00_3609)), BUNSPEC);
		}

	}



/* &lambda1468 */
	obj_t BGl_z62lambda1468z62zz__threadz00(obj_t BgL_envz00_3610,
		obj_t BgL_oz00_3611)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3611)))->BgL_z52namez52);
		}

	}



/* &<@anonymous:1463> */
	obj_t BGl_z62zc3z04anonymousza31463ze3ze5zz__threadz00(obj_t BgL_envz00_3612)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1462 */
	obj_t BGl_z62lambda1462z62zz__threadz00(obj_t BgL_envz00_3613,
		obj_t BgL_oz00_3614, obj_t BgL_vz00_3615)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3614)))->
					BgL_endzd2exceptionzd2) = ((obj_t) BgL_vz00_3615), BUNSPEC);
		}

	}



/* &lambda1461 */
	obj_t BGl_z62lambda1461z62zz__threadz00(obj_t BgL_envz00_3616,
		obj_t BgL_oz00_3617)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3617)))->BgL_endzd2exceptionzd2);
		}

	}



/* &<@anonymous:1456> */
	obj_t BGl_z62zc3z04anonymousza31456ze3ze5zz__threadz00(obj_t BgL_envz00_3618)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1455 */
	obj_t BGl_z62lambda1455z62zz__threadz00(obj_t BgL_envz00_3619,
		obj_t BgL_oz00_3620, obj_t BgL_vz00_3621)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3620)))->BgL_endzd2resultzd2) =
				((obj_t) BgL_vz00_3621), BUNSPEC);
		}

	}



/* &lambda1454 */
	obj_t BGl_z62lambda1454z62zz__threadz00(obj_t BgL_envz00_3622,
		obj_t BgL_oz00_3623)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3623)))->BgL_endzd2resultzd2);
		}

	}



/* &<@anonymous:1448> */
	obj_t BGl_z62zc3z04anonymousza31448ze3ze5zz__threadz00(obj_t BgL_envz00_3624)
	{
		{	/* Llib/thread.scm 170 */
			return BBOOL(((bool_t) 0));
		}

	}



/* &lambda1447 */
	obj_t BGl_z62lambda1447z62zz__threadz00(obj_t BgL_envz00_3625,
		obj_t BgL_oz00_3626, obj_t BgL_vz00_3627)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3626)))->BgL_z52cleanupz52) =
				((obj_t) BgL_vz00_3627), BUNSPEC);
		}

	}



/* &lambda1446 */
	obj_t BGl_z62lambda1446z62zz__threadz00(obj_t BgL_envz00_3628,
		obj_t BgL_oz00_3629)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3629)))->BgL_z52cleanupz52);
		}

	}



/* &<@anonymous:1439> */
	obj_t BGl_z62zc3z04anonymousza31439ze3ze5zz__threadz00(obj_t BgL_envz00_3630)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1438 */
	obj_t BGl_z62lambda1438z62zz__threadz00(obj_t BgL_envz00_3631,
		obj_t BgL_oz00_3632, obj_t BgL_vz00_3633)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3632)))->BgL_z52specificz52) =
				((obj_t) BgL_vz00_3633), BUNSPEC);
		}

	}



/* &lambda1437 */
	obj_t BGl_z62lambda1437z62zz__threadz00(obj_t BgL_envz00_3634,
		obj_t BgL_oz00_3635)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3635)))->BgL_z52specificz52);
		}

	}



/* &lambda1432 */
	obj_t BGl_z62lambda1432z62zz__threadz00(obj_t BgL_envz00_3636,
		obj_t BgL_oz00_3637, obj_t BgL_vz00_3638)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3637)))->BgL_bodyz00) = ((obj_t)
					((obj_t) BgL_vz00_3638)), BUNSPEC);
		}

	}



/* &lambda1431 */
	obj_t BGl_z62lambda1431z62zz__threadz00(obj_t BgL_envz00_3639,
		obj_t BgL_oz00_3640)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3640)))->BgL_bodyz00);
		}

	}



/* &<@anonymous:1382> */
	obj_t BGl_z62zc3z04anonymousza31382ze3ze5zz__threadz00(obj_t BgL_envz00_3641,
		obj_t BgL_new1042z00_3642)
	{
		{	/* Llib/thread.scm 164 */
			{
				BgL_threadz00_bglt BgL_auxz00_5826;

				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1042z00_3642)))->BgL_namez00) =
					((obj_t) BUNSPEC), BUNSPEC);
				BgL_auxz00_5826 = ((BgL_threadz00_bglt) BgL_new1042z00_3642);
				return ((obj_t) BgL_auxz00_5826);
			}
		}

	}



/* &lambda1380 */
	BgL_threadz00_bglt BGl_z62lambda1380z62zz__threadz00(obj_t BgL_envz00_3643)
	{
		{	/* Llib/thread.scm 164 */
			{	/* Llib/thread.scm 164 */
				BgL_threadz00_bglt BgL_new1041z00_4166;

				BgL_new1041z00_4166 =
					((BgL_threadz00_bglt) BOBJECT(GC_MALLOC(sizeof(struct
								BgL_threadz00_bgl))));
				{	/* Llib/thread.scm 164 */
					long BgL_arg1381z00_4167;

					BgL_arg1381z00_4167 = BGL_CLASS_NUM(BGl_threadz00zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1041z00_4166), BgL_arg1381z00_4167);
				}
				return BgL_new1041z00_4166;
			}
		}

	}



/* &<@anonymous:1414> */
	obj_t BGl_z62zc3z04anonymousza31414ze3ze5zz__threadz00(obj_t BgL_envz00_3644,
		obj_t BgL_oz00_3645, obj_t BgL_vz00_3646)
	{
		{	/* Llib/thread.scm 168 */
			return
				BGl_threadzd2cleanupzd2setz12z12zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3645), BgL_vz00_3646);
		}

	}



/* &<@anonymous:1412> */
	obj_t BGl_z62zc3z04anonymousza31412ze3ze5zz__threadz00(obj_t BgL_envz00_3647,
		obj_t BgL_oz00_3648)
	{
		{	/* Llib/thread.scm 168 */
			return
				BGl_threadzd2cleanupzd2zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3648));
		}

	}



/* &<@anonymous:1406> */
	obj_t BGl_z62zc3z04anonymousza31406ze3ze5zz__threadz00(obj_t BgL_envz00_3649,
		obj_t BgL_oz00_3650, obj_t BgL_vz00_3651)
	{
		{	/* Llib/thread.scm 167 */
			return
				BGl_threadzd2specificzd2setz12z12zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3650), BgL_vz00_3651);
		}

	}



/* &<@anonymous:1404> */
	obj_t BGl_z62zc3z04anonymousza31404ze3ze5zz__threadz00(obj_t BgL_envz00_3652,
		obj_t BgL_oz00_3653)
	{
		{	/* Llib/thread.scm 167 */
			return
				BGl_threadzd2specificzd2zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3653));
		}

	}



/* &<@anonymous:1399> */
	obj_t BGl_z62zc3z04anonymousza31399ze3ze5zz__threadz00(obj_t BgL_envz00_3654,
		obj_t BgL_oz00_3655, obj_t BgL_vz00_3656)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2setterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3655), (int) (1L), BgL_vz00_3656);
		}

	}



/* &<@anonymous:1398> */
	obj_t BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00(obj_t BgL_envz00_3657,
		obj_t BgL_oz00_3658)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2getterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3658), (int) (1L));
		}

	}



/* &<@anonymous:1394> */
	obj_t BGl_z62zc3z04anonymousza31394ze3ze5zz__threadz00(obj_t BgL_envz00_3659,
		obj_t BgL_oz00_3660, obj_t BgL_vz00_3661)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2setterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3660), (int) (0L), BgL_vz00_3661);
		}

	}



/* &<@anonymous:1393> */
	obj_t BGl_z62zc3z04anonymousza31393ze3ze5zz__threadz00(obj_t BgL_envz00_3662,
		obj_t BgL_oz00_3663)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2getterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3663), (int) (0L));
		}

	}



/* &<@anonymous:1389> */
	obj_t BGl_z62zc3z04anonymousza31389ze3ze5zz__threadz00(obj_t BgL_envz00_3664)
	{
		{	/* Llib/thread.scm 164 */
			return BGl_gensymz00zz__r4_symbols_6_4z00(BGl_symbol2221z00zz__threadz00);
		}

	}



/* &lambda1388 */
	obj_t BGl_z62lambda1388z62zz__threadz00(obj_t BgL_envz00_3665,
		obj_t BgL_oz00_3666, obj_t BgL_vz00_3667)
	{
		{	/* Llib/thread.scm 164 */
			return
				((((BgL_threadz00_bglt) COBJECT(
							((BgL_threadz00_bglt) BgL_oz00_3666)))->BgL_namez00) =
				((obj_t) BgL_vz00_3667), BUNSPEC);
		}

	}



/* &lambda1387 */
	obj_t BGl_z62lambda1387z62zz__threadz00(obj_t BgL_envz00_3668,
		obj_t BgL_oz00_3669)
	{
		{	/* Llib/thread.scm 164 */
			return
				(((BgL_threadz00_bglt) COBJECT(
						((BgL_threadz00_bglt) BgL_oz00_3669)))->BgL_namez00);
		}

	}



/* &<@anonymous:1370> */
	obj_t BGl_z62zc3z04anonymousza31370ze3ze5zz__threadz00(obj_t BgL_envz00_3670,
		obj_t BgL_new1039z00_3671)
	{
		{	/* Llib/thread.scm 161 */
			{
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5860;

				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1039z00_3671)))->
						BgL_namez00) = ((obj_t) BGl_string2317z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5860 = ((BgL_threadzd2backendzd2_bglt) BgL_new1039z00_3671);
				return ((obj_t) BgL_auxz00_5860);
			}
		}

	}



/* &lambda1368 */
	BgL_threadzd2backendzd2_bglt BGl_z62lambda1368z62zz__threadz00(obj_t
		BgL_envz00_3672)
	{
		{	/* Llib/thread.scm 161 */
			{	/* Llib/thread.scm 161 */
				BgL_threadzd2backendzd2_bglt BgL_new1038z00_4171;

				BgL_new1038z00_4171 =
					((BgL_threadzd2backendzd2_bglt) BOBJECT(GC_MALLOC(sizeof(struct
								BgL_threadzd2backendzd2_bgl))));
				{	/* Llib/thread.scm 161 */
					long BgL_arg1369z00_4172;

					BgL_arg1369z00_4172 =
						BGL_CLASS_NUM(BGl_threadzd2backendzd2zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1038z00_4171), BgL_arg1369z00_4172);
				}
				return BgL_new1038z00_4171;
			}
		}

	}



/* &lambda1366 */
	BgL_threadzd2backendzd2_bglt BGl_z62lambda1366z62zz__threadz00(obj_t
		BgL_envz00_3673, obj_t BgL_name1037z00_3674)
	{
		{	/* Llib/thread.scm 161 */
			{	/* Llib/thread.scm 161 */
				BgL_threadzd2backendzd2_bglt BgL_new1113z00_4174;

				{	/* Llib/thread.scm 161 */
					BgL_threadzd2backendzd2_bglt BgL_new1112z00_4175;

					BgL_new1112z00_4175 =
						((BgL_threadzd2backendzd2_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_threadzd2backendzd2_bgl))));
					{	/* Llib/thread.scm 161 */
						long BgL_arg1367z00_4176;

						BgL_arg1367z00_4176 =
							BGL_CLASS_NUM(BGl_threadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1112z00_4175), BgL_arg1367z00_4176);
					}
					BgL_new1113z00_4174 = BgL_new1112z00_4175;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(BgL_new1113z00_4174))->
						BgL_namez00) = ((obj_t) ((obj_t) BgL_name1037z00_3674)), BUNSPEC);
				return BgL_new1113z00_4174;
			}
		}

	}



/* &lambda1375 */
	obj_t BGl_z62lambda1375z62zz__threadz00(obj_t BgL_envz00_3675,
		obj_t BgL_oz00_3676, obj_t BgL_vz00_3677)
	{
		{	/* Llib/thread.scm 161 */
			return
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
							((BgL_threadzd2backendzd2_bglt) BgL_oz00_3676)))->BgL_namez00) =
				((obj_t) ((obj_t) BgL_vz00_3677)), BUNSPEC);
		}

	}



/* &lambda1374 */
	obj_t BGl_z62lambda1374z62zz__threadz00(obj_t BgL_envz00_3678,
		obj_t BgL_oz00_3679)
	{
		{	/* Llib/thread.scm 161 */
			return
				(((BgL_threadzd2backendzd2_bglt) COBJECT(
						((BgL_threadzd2backendzd2_bglt) BgL_oz00_3679)))->BgL_namez00);
		}

	}



/* generic-init */
	obj_t BGl_genericzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
				BGl_proc2319z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2320z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
				BGl_proc2321z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2322z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
				BGl_proc2323z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2324z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
				BGl_proc2325z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2326z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
				BGl_proc2327z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2328z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2startz12zd2envz12zz__threadz00,
				BGl_proc2329z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2330z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
				BGl_proc2331z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2332z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2joinz12zd2envz12zz__threadz00,
				BGl_proc2333z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2334z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
				BGl_proc2335z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2336z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2killz12zd2envz12zz__threadz00,
				BGl_proc2337z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2338z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2specificzd2envz00zz__threadz00,
				BGl_proc2339z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2340z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
				BGl_proc2341z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2342z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2cleanupzd2envz00zz__threadz00,
				BGl_proc2343z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2344z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
				BGl_proc2345z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2346z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2namezd2envz00zz__threadz00, BGl_proc2347z00zz__threadz00,
				BGl_threadz00zz__threadz00, BGl_string2348z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
				BGl_proc2349z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2350z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
				BGl_proc2351z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2352z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
				BGl_proc2353z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2354z00zz__threadz00);
			return
				BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
				BGl_proc2355z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2356z00zz__threadz00);
		}

	}



/* &%user-thread-yield!1231 */
	obj_t BGl_z62z52userzd2threadzd2yieldz121231z22zz__threadz00(obj_t
		BgL_envz00_3701, obj_t BgL_oz00_3702)
	{
		{	/* Llib/thread.scm 500 */
			return BUNSPEC;
		}

	}



/* &%user-thread-sleep!1228 */
	obj_t BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00(obj_t
		BgL_envz00_3703, obj_t BgL_oz00_3704, obj_t BgL_dz00_3705)
	{
		{	/* Llib/thread.scm 473 */
			if (BGL_DATEP(BgL_dz00_3705))
				{	/* Llib/thread.scm 476 */
					long BgL_cdtz00_4182;

					BgL_cdtz00_4182 =
						bgl_date_to_seconds(bgl_nanoseconds_to_date(bgl_current_nanoseconds
							()));
					{	/* Llib/thread.scm 476 */
						long BgL_dtz00_4183;

						BgL_dtz00_4183 = bgl_date_to_seconds(BgL_dz00_3705);
						{	/* Llib/thread.scm 477 */
							obj_t BgL_az00_4184;

							{	/* Llib/thread.scm 478 */
								long BgL_a1153z00_4185;

								{	/* Llib/thread.scm 478 */
									long BgL_res1963z00_4186;

									{	/* Llib/thread.scm 478 */
										long BgL_tmpz00_5905;

										BgL_tmpz00_5905 = (BgL_dtz00_4183 - BgL_cdtz00_4182);
										BgL_res1963z00_4186 = (long) (BgL_tmpz00_5905);
									}
									BgL_a1153z00_4185 = BgL_res1963z00_4186;
								}
								BgL_az00_4184 =
									BGl_2za2za2zz__r4_numbers_6_5z00(make_belong
									(BgL_a1153z00_4185), BINT(1000000L));
							}
							{	/* Llib/thread.scm 478 */

								{	/* Llib/thread.scm 479 */
									bool_t BgL_test2731z00_5911;

									{	/* Llib/thread.scm 479 */
										long BgL_n1z00_4187;

										BgL_n1z00_4187 = BELONG_TO_LONG(BgL_az00_4184);
										BgL_test2731z00_5911 = (BgL_n1z00_4187 > ((long) 0));
									}
									if (BgL_test2731z00_5911)
										{	/* Llib/thread.scm 479 */
											long BgL_arg1508z00_4188;

											{	/* Llib/thread.scm 479 */
												long BgL_xz00_4189;

												BgL_xz00_4189 = BELONG_TO_LONG(BgL_az00_4184);
												BgL_arg1508z00_4188 = (long) (BgL_xz00_4189);
											}
											bgl_sleep(BgL_arg1508z00_4188);
											BUNSPEC;
											return BINT(BgL_arg1508z00_4188);
										}
									else
										{	/* Llib/thread.scm 479 */
											return BFALSE;
										}
								}
							}
						}
					}
				}
			else
				{	/* Llib/thread.scm 475 */
					if (INTEGERP(BgL_dz00_3705))
						{	/* Llib/thread.scm 481 */
							obj_t BgL_arg1511z00_4190;

							{	/* Llib/thread.scm 481 */
								obj_t BgL_tmpz00_4191;

								BgL_tmpz00_4191 = BINT(0L);
								{	/* Llib/thread.scm 481 */
									bool_t BgL_test2733z00_5921;

									{	/* Llib/thread.scm 481 */
										obj_t BgL_tmpz00_5922;

										BgL_tmpz00_5922 = BINT(1000L);
										BgL_test2733z00_5921 =
											BGL_MULFX_OV(BgL_dz00_3705, BgL_tmpz00_5922,
											BgL_tmpz00_4191);
									}
									if (BgL_test2733z00_5921)
										{	/* Llib/thread.scm 481 */
											BgL_arg1511z00_4190 =
												bgl_bignum_mul(bgl_long_to_bignum(
													(long) CINT(BgL_dz00_3705)),
												bgl_long_to_bignum(1000L));
										}
									else
										{	/* Llib/thread.scm 481 */
											BgL_arg1511z00_4190 = BgL_tmpz00_4191;
										}
								}
							}
							{	/* Llib/thread.scm 481 */
								long BgL_msz00_4192;

								BgL_msz00_4192 = (long) CINT(BgL_arg1511z00_4190);
								bgl_sleep(BgL_msz00_4192);
								BUNSPEC;
								return BINT(BgL_msz00_4192);
							}
						}
					else
						{	/* Llib/thread.scm 480 */
							if (ELONGP(BgL_dz00_3705))
								{	/* Llib/thread.scm 483 */
									obj_t BgL_arg1513z00_4193;

									{	/* Llib/thread.scm 483 */
										long BgL_a1154z00_4194;

										{	/* Llib/thread.scm 483 */
											long BgL_xz00_4195;

											BgL_xz00_4195 = BELONG_TO_LONG(BgL_dz00_3705);
											BgL_a1154z00_4194 = (long) (BgL_xz00_4195);
										}
										{	/* Llib/thread.scm 483 */
											obj_t BgL_za71za7_4196;

											BgL_za71za7_4196 = BINT(BgL_a1154z00_4194);
											{	/* Llib/thread.scm 483 */
												obj_t BgL_tmpz00_4197;

												BgL_tmpz00_4197 = BINT(0L);
												{	/* Llib/thread.scm 483 */
													bool_t BgL_test2735z00_5938;

													{	/* Llib/thread.scm 483 */
														obj_t BgL_tmpz00_5939;

														BgL_tmpz00_5939 = BINT(1000L);
														BgL_test2735z00_5938 =
															BGL_MULFX_OV(BgL_za71za7_4196, BgL_tmpz00_5939,
															BgL_tmpz00_4197);
													}
													if (BgL_test2735z00_5938)
														{	/* Llib/thread.scm 483 */
															BgL_arg1513z00_4193 =
																bgl_bignum_mul(bgl_long_to_bignum(
																	(long) CINT(BgL_za71za7_4196)),
																bgl_long_to_bignum(1000L));
														}
													else
														{	/* Llib/thread.scm 483 */
															BgL_arg1513z00_4193 = BgL_tmpz00_4197;
														}
												}
											}
										}
									}
									{	/* Llib/thread.scm 483 */
										long BgL_msz00_4198;

										BgL_msz00_4198 = (long) CINT(BgL_arg1513z00_4193);
										bgl_sleep(BgL_msz00_4198);
										BUNSPEC;
										return BINT(BgL_msz00_4198);
									}
								}
							else
								{	/* Llib/thread.scm 482 */
									if (LLONGP(BgL_dz00_3705))
										{	/* Llib/thread.scm 485 */
											obj_t BgL_arg1515z00_4199;

											{	/* Llib/thread.scm 485 */
												long BgL_a1155z00_4200;

												{	/* Llib/thread.scm 485 */
													BGL_LONGLONG_T BgL_tmpz00_5951;

													BgL_tmpz00_5951 = BLLONG_TO_LLONG(BgL_dz00_3705);
													BgL_a1155z00_4200 = LLONG_TO_LONG(BgL_tmpz00_5951);
												}
												{	/* Llib/thread.scm 485 */
													obj_t BgL_za71za7_4201;

													BgL_za71za7_4201 = BINT(BgL_a1155z00_4200);
													{	/* Llib/thread.scm 485 */
														obj_t BgL_tmpz00_4202;

														BgL_tmpz00_4202 = BINT(0L);
														{	/* Llib/thread.scm 485 */
															bool_t BgL_test2737z00_5956;

															{	/* Llib/thread.scm 485 */
																obj_t BgL_tmpz00_5957;

																BgL_tmpz00_5957 = BINT(1000L);
																BgL_test2737z00_5956 =
																	BGL_MULFX_OV(BgL_za71za7_4201,
																	BgL_tmpz00_5957, BgL_tmpz00_4202);
															}
															if (BgL_test2737z00_5956)
																{	/* Llib/thread.scm 485 */
																	BgL_arg1515z00_4199 =
																		bgl_bignum_mul(bgl_long_to_bignum(
																			(long) CINT(BgL_za71za7_4201)),
																		bgl_long_to_bignum(1000L));
																}
															else
																{	/* Llib/thread.scm 485 */
																	BgL_arg1515z00_4199 = BgL_tmpz00_4202;
																}
														}
													}
												}
											}
											{	/* Llib/thread.scm 485 */
												long BgL_msz00_4203;

												BgL_msz00_4203 = (long) CINT(BgL_arg1515z00_4199);
												bgl_sleep(BgL_msz00_4203);
												BUNSPEC;
												return BINT(BgL_msz00_4203);
											}
										}
									else
										{	/* Llib/thread.scm 486 */
											bool_t BgL_test2738z00_5967;

											if (INTEGERP(BgL_dz00_3705))
												{	/* Llib/thread.scm 486 */
													BgL_test2738z00_5967 = ((bool_t) 1);
												}
											else
												{	/* Llib/thread.scm 486 */
													BgL_test2738z00_5967 = REALP(BgL_dz00_3705);
												}
											if (BgL_test2738z00_5967)
												{	/* Llib/thread.scm 487 */
													long BgL_arg1517z00_4204;

													{	/* Llib/thread.scm 487 */
														double BgL_arg1520z00_4205;

														if (BGL_FAST_REALP(BgL_dz00_3705))
															{	/* Llib/thread.scm 487 */
																double BgL_arg1522z00_4206;

																BgL_arg1522z00_4206 =
																	BGL_FAST_REAL_TO_DOUBLE(BgL_dz00_3705);
																BgL_arg1520z00_4205 =
																	(BgL_arg1522z00_4206 * 1000000.0);
															}
														else
															{	/* Llib/thread.scm 487 */
																BgL_arg1520z00_4205 =
																	(BGl_numberzd2ze3flonumz31zz__r4_numbers_6_5z00
																	(BgL_dz00_3705) * 1000000.0);
															}
														BgL_arg1517z00_4204 = (long) (BgL_arg1520z00_4205);
													}
													bgl_sleep(BgL_arg1517z00_4204);
													BUNSPEC;
													return BINT(BgL_arg1517z00_4204);
												}
											else
												{	/* Llib/thread.scm 486 */
													return
														BGl_bigloozd2typezd2errorz00zz__errorz00
														(BGl_symbol2357z00zz__threadz00,
														BGl_string2359z00zz__threadz00, BgL_dz00_3705);
												}
										}
								}
						}
				}
		}

	}



/* &%user-current-thread1225 */
	obj_t BGl_z62z52userzd2currentzd2thread1225z30zz__threadz00(obj_t
		BgL_envz00_3706, obj_t BgL_oz00_3707)
	{
		{	/* Llib/thread.scm 451 */
			return ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3707));
		}

	}



/* &thread-name-set!1218 */
	obj_t BGl_z62threadzd2namezd2setz121218z70zz__threadz00(obj_t BgL_envz00_3708,
		obj_t BgL_thz00_3709, obj_t BgL_vz00_3710)
	{
		{	/* Llib/thread.scm 440 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2360z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3709)));
		}

	}



/* &thread-name1216 */
	obj_t BGl_z62threadzd2name1216zb0zz__threadz00(obj_t BgL_envz00_3711,
		obj_t BgL_thz00_3712)
	{
		{	/* Llib/thread.scm 435 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2362z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3712)));
		}

	}



/* &thread-cleanup-set!1214 */
	obj_t BGl_z62threadzd2cleanupzd2setz121214z70zz__threadz00(obj_t
		BgL_envz00_3713, obj_t BgL_thz00_3714, obj_t BgL_vz00_3715)
	{
		{	/* Llib/thread.scm 430 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2363z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3714)));
		}

	}



/* &thread-cleanup1212 */
	obj_t BGl_z62threadzd2cleanup1212zb0zz__threadz00(obj_t BgL_envz00_3716,
		obj_t BgL_thz00_3717)
	{
		{	/* Llib/thread.scm 425 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2364z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3717)));
		}

	}



/* &thread-specific-set!1210 */
	obj_t BGl_z62threadzd2specificzd2setz121210z70zz__threadz00(obj_t
		BgL_envz00_3718, obj_t BgL_thz00_3719, obj_t BgL_vz00_3720)
	{
		{	/* Llib/thread.scm 420 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2365z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3719)));
		}

	}



/* &thread-specific1207 */
	obj_t BGl_z62threadzd2specific1207zb0zz__threadz00(obj_t BgL_envz00_3721,
		obj_t BgL_thz00_3722)
	{
		{	/* Llib/thread.scm 415 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2366z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3722)));
		}

	}



/* &thread-kill!1205 */
	obj_t BGl_z62threadzd2killz121205za2zz__threadz00(obj_t BgL_envz00_3723,
		obj_t BgL_thz00_3724, obj_t BgL_nz00_3725)
	{
		{	/* Llib/thread.scm 410 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2367z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3724)));
		}

	}



/* &thread-terminate!1203 */
	obj_t BGl_z62threadzd2terminatez121203za2zz__threadz00(obj_t BgL_envz00_3726,
		obj_t BgL_thz00_3727)
	{
		{	/* Llib/thread.scm 405 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2368z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3727)));
		}

	}



/* &thread-join!1201 */
	obj_t BGl_z62threadzd2joinz121201za2zz__threadz00(obj_t BgL_envz00_3728,
		obj_t BgL_thz00_3729, obj_t BgL_timeoutz00_3730)
	{
		{	/* Llib/thread.scm 400 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2369z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3729)));
		}

	}



/* &thread-start-joinabl1199 */
	obj_t BGl_z62threadzd2startzd2joinabl1199z62zz__threadz00(obj_t
		BgL_envz00_3731, obj_t BgL_thz00_3732)
	{
		{	/* Llib/thread.scm 395 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2370z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3732)));
		}

	}



/* &thread-start!1197 */
	obj_t BGl_z62threadzd2startz121197za2zz__threadz00(obj_t BgL_envz00_3733,
		obj_t BgL_thz00_3734, obj_t BgL_scz00_3735)
	{
		{	/* Llib/thread.scm 390 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2371z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3734)));
		}

	}



/* &thread-initialize!1195 */
	obj_t BGl_z62threadzd2initializa7ez121195z05zz__threadz00(obj_t
		BgL_envz00_3736, obj_t BgL_thz00_3737)
	{
		{	/* Llib/thread.scm 384 */
			return ((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3737));
		}

	}



/* &tb-condvar-initializ1187 */
	obj_t BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00(obj_t
		BgL_envz00_3738, obj_t BgL_tbz00_3739, obj_t BgL_condvarz00_3740)
	{
		{	/* Llib/thread.scm 355 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2372z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3739)));
		}

	}



/* &tb-mutex-initialize!1185 */
	obj_t BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00(obj_t
		BgL_envz00_3741, obj_t BgL_tbz00_3742, obj_t BgL_mutexz00_3743)
	{
		{	/* Llib/thread.scm 350 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2373z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3742)));
		}

	}



/* &tb-current-thread1179 */
	obj_t BGl_z62tbzd2currentzd2thread1179z62zz__threadz00(obj_t BgL_envz00_3744,
		obj_t BgL_tbz00_3745)
	{
		{	/* Llib/thread.scm 326 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2374z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3745)));
		}

	}



/* &tb-make-thread1176 */
	obj_t BGl_z62tbzd2makezd2thread1176z62zz__threadz00(obj_t BgL_envz00_3746,
		obj_t BgL_tbz00_3747, obj_t BgL_bodyz00_3748, obj_t BgL_namez00_3749)
	{
		{	/* Llib/thread.scm 321 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2375z00zz__threadz00,
				BGl_string2361z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3747)));
		}

	}



/* tb-make-thread */
	BGL_EXPORTED_DEF BgL_threadz00_bglt
		BGl_tbzd2makezd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt
		BgL_tbz00_7, obj_t BgL_bodyz00_8, obj_t BgL_namez00_9)
	{
		{	/* Llib/thread.scm 321 */
			{	/* Llib/thread.scm 321 */
				obj_t BgL_method1178z00_1644;

				{	/* Llib/thread.scm 321 */
					obj_t BgL_res1968z00_2551;

					{	/* Llib/thread.scm 321 */
						long BgL_objzd2classzd2numz00_2522;

						BgL_objzd2classzd2numz00_2522 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_tbz00_7));
						{	/* Llib/thread.scm 321 */
							obj_t BgL_arg1949z00_2523;

							BgL_arg1949z00_2523 =
								PROCEDURE_REF(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 321 */
								int BgL_offsetz00_2526;

								BgL_offsetz00_2526 = (int) (BgL_objzd2classzd2numz00_2522);
								{	/* Llib/thread.scm 321 */
									long BgL_offsetz00_2527;

									BgL_offsetz00_2527 =
										((long) (BgL_offsetz00_2526) - OBJECT_TYPE);
									{	/* Llib/thread.scm 321 */
										long BgL_modz00_2528;

										BgL_modz00_2528 =
											(BgL_offsetz00_2527 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 321 */
											long BgL_restz00_2530;

											BgL_restz00_2530 =
												(BgL_offsetz00_2527 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 321 */

												{	/* Llib/thread.scm 321 */
													obj_t BgL_bucketz00_2532;

													BgL_bucketz00_2532 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2523), BgL_modz00_2528);
													BgL_res1968z00_2551 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2532), BgL_restz00_2530);
					}}}}}}}}
					BgL_method1178z00_1644 = BgL_res1968z00_2551;
				}
				return
					((BgL_threadz00_bglt)
					BGL_PROCEDURE_CALL3(BgL_method1178z00_1644,
						((obj_t) BgL_tbz00_7), BgL_bodyz00_8, BgL_namez00_9));
			}
		}

	}



/* &tb-make-thread */
	BgL_threadz00_bglt BGl_z62tbzd2makezd2threadz62zz__threadz00(obj_t
		BgL_envz00_3750, obj_t BgL_tbz00_3751, obj_t BgL_bodyz00_3752,
		obj_t BgL_namez00_3753)
	{
		{	/* Llib/thread.scm 321 */
			{	/* Llib/thread.scm 321 */
				obj_t BgL_auxz00_6093;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_6063;

				if (PROCEDUREP(BgL_bodyz00_3752))
					{	/* Llib/thread.scm 321 */
						BgL_auxz00_6093 = BgL_bodyz00_3752;
					}
				else
					{
						obj_t BgL_auxz00_6096;

						BgL_auxz00_6096 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(12558L), BGl_string2376z00zz__threadz00,
							BGl_string2223z00zz__threadz00, BgL_bodyz00_3752);
						FAILURE(BgL_auxz00_6096, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 321 */
					bool_t BgL_test2741z00_6064;

					{	/* Llib/thread.scm 321 */
						obj_t BgL_classz00_4229;

						BgL_classz00_4229 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3751))
							{	/* Llib/thread.scm 321 */
								BgL_objectz00_bglt BgL_arg1947z00_4231;
								long BgL_arg1948z00_4232;

								BgL_arg1947z00_4231 = (BgL_objectz00_bglt) (BgL_tbz00_3751);
								BgL_arg1948z00_4232 = BGL_CLASS_DEPTH(BgL_classz00_4229);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 321 */
										long BgL_idxz00_4240;

										BgL_idxz00_4240 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4231);
										{	/* Llib/thread.scm 321 */
											obj_t BgL_arg1938z00_4241;

											{	/* Llib/thread.scm 321 */
												long BgL_arg1939z00_4242;

												BgL_arg1939z00_4242 =
													(BgL_idxz00_4240 + BgL_arg1948z00_4232);
												BgL_arg1938z00_4241 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4242);
											}
											BgL_test2741z00_6064 =
												(BgL_arg1938z00_4241 == BgL_classz00_4229);
									}}
								else
									{	/* Llib/thread.scm 321 */
										bool_t BgL_res2061z00_4247;

										{	/* Llib/thread.scm 321 */
											obj_t BgL_oclassz00_4251;

											{	/* Llib/thread.scm 321 */
												obj_t BgL_arg1954z00_4253;
												long BgL_arg1955z00_4254;

												BgL_arg1954z00_4253 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 321 */
													long BgL_arg1956z00_4255;

													BgL_arg1956z00_4255 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4231);
													BgL_arg1955z00_4254 =
														(BgL_arg1956z00_4255 - OBJECT_TYPE);
												}
												BgL_oclassz00_4251 =
													VECTOR_REF(BgL_arg1954z00_4253, BgL_arg1955z00_4254);
											}
											{	/* Llib/thread.scm 321 */
												bool_t BgL__ortest_1149z00_4261;

												BgL__ortest_1149z00_4261 =
													(BgL_classz00_4229 == BgL_oclassz00_4251);
												if (BgL__ortest_1149z00_4261)
													{	/* Llib/thread.scm 321 */
														BgL_res2061z00_4247 = BgL__ortest_1149z00_4261;
													}
												else
													{	/* Llib/thread.scm 321 */
														long BgL_odepthz00_4262;

														{	/* Llib/thread.scm 321 */
															obj_t BgL_arg1942z00_4263;

															BgL_arg1942z00_4263 = (BgL_oclassz00_4251);
															BgL_odepthz00_4262 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4263);
														}
														if ((BgL_arg1948z00_4232 < BgL_odepthz00_4262))
															{	/* Llib/thread.scm 321 */
																obj_t BgL_arg1940z00_4267;

																{	/* Llib/thread.scm 321 */
																	obj_t BgL_arg1941z00_4268;

																	BgL_arg1941z00_4268 = (BgL_oclassz00_4251);
																	BgL_arg1940z00_4267 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4268,
																		BgL_arg1948z00_4232);
																}
																BgL_res2061z00_4247 =
																	(BgL_arg1940z00_4267 == BgL_classz00_4229);
															}
														else
															{	/* Llib/thread.scm 321 */
																BgL_res2061z00_4247 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2741z00_6064 = BgL_res2061z00_4247;
									}
							}
						else
							{	/* Llib/thread.scm 321 */
								BgL_test2741z00_6064 = ((bool_t) 0);
							}
					}
					if (BgL_test2741z00_6064)
						{	/* Llib/thread.scm 321 */
							BgL_auxz00_6063 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3751);
						}
					else
						{
							obj_t BgL_auxz00_6089;

							BgL_auxz00_6089 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(12558L), BGl_string2376z00zz__threadz00,
								BGl_string2215z00zz__threadz00, BgL_tbz00_3751);
							FAILURE(BgL_auxz00_6089, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2makezd2threadz00zz__threadz00(BgL_auxz00_6063,
					BgL_auxz00_6093, BgL_namez00_3753);
			}
		}

	}



/* tb-current-thread */
	BGL_EXPORTED_DEF obj_t
		BGl_tbzd2currentzd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt
		BgL_tbz00_10)
	{
		{	/* Llib/thread.scm 326 */
			{	/* Llib/thread.scm 326 */
				obj_t BgL_method1180z00_1645;

				{	/* Llib/thread.scm 326 */
					obj_t BgL_res1973z00_2582;

					{	/* Llib/thread.scm 326 */
						long BgL_objzd2classzd2numz00_2553;

						BgL_objzd2classzd2numz00_2553 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_tbz00_10));
						{	/* Llib/thread.scm 326 */
							obj_t BgL_arg1949z00_2554;

							BgL_arg1949z00_2554 =
								PROCEDURE_REF(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 326 */
								int BgL_offsetz00_2557;

								BgL_offsetz00_2557 = (int) (BgL_objzd2classzd2numz00_2553);
								{	/* Llib/thread.scm 326 */
									long BgL_offsetz00_2558;

									BgL_offsetz00_2558 =
										((long) (BgL_offsetz00_2557) - OBJECT_TYPE);
									{	/* Llib/thread.scm 326 */
										long BgL_modz00_2559;

										BgL_modz00_2559 =
											(BgL_offsetz00_2558 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 326 */
											long BgL_restz00_2561;

											BgL_restz00_2561 =
												(BgL_offsetz00_2558 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 326 */

												{	/* Llib/thread.scm 326 */
													obj_t BgL_bucketz00_2563;

													BgL_bucketz00_2563 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2554), BgL_modz00_2559);
													BgL_res1973z00_2582 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2563), BgL_restz00_2561);
					}}}}}}}}
					BgL_method1180z00_1645 = BgL_res1973z00_2582;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1180z00_1645, ((obj_t) BgL_tbz00_10));
			}
		}

	}



/* &tb-current-thread */
	obj_t BGl_z62tbzd2currentzd2threadz62zz__threadz00(obj_t BgL_envz00_3754,
		obj_t BgL_tbz00_3755)
	{
		{	/* Llib/thread.scm 326 */
			{	/* Llib/thread.scm 326 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_6131;

				{	/* Llib/thread.scm 326 */
					bool_t BgL_test2747z00_6132;

					{	/* Llib/thread.scm 326 */
						obj_t BgL_classz00_4269;

						BgL_classz00_4269 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3755))
							{	/* Llib/thread.scm 326 */
								BgL_objectz00_bglt BgL_arg1947z00_4271;
								long BgL_arg1948z00_4272;

								BgL_arg1947z00_4271 = (BgL_objectz00_bglt) (BgL_tbz00_3755);
								BgL_arg1948z00_4272 = BGL_CLASS_DEPTH(BgL_classz00_4269);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 326 */
										long BgL_idxz00_4280;

										BgL_idxz00_4280 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4271);
										{	/* Llib/thread.scm 326 */
											obj_t BgL_arg1938z00_4281;

											{	/* Llib/thread.scm 326 */
												long BgL_arg1939z00_4282;

												BgL_arg1939z00_4282 =
													(BgL_idxz00_4280 + BgL_arg1948z00_4272);
												BgL_arg1938z00_4281 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4282);
											}
											BgL_test2747z00_6132 =
												(BgL_arg1938z00_4281 == BgL_classz00_4269);
									}}
								else
									{	/* Llib/thread.scm 326 */
										bool_t BgL_res2061z00_4287;

										{	/* Llib/thread.scm 326 */
											obj_t BgL_oclassz00_4291;

											{	/* Llib/thread.scm 326 */
												obj_t BgL_arg1954z00_4293;
												long BgL_arg1955z00_4294;

												BgL_arg1954z00_4293 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 326 */
													long BgL_arg1956z00_4295;

													BgL_arg1956z00_4295 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4271);
													BgL_arg1955z00_4294 =
														(BgL_arg1956z00_4295 - OBJECT_TYPE);
												}
												BgL_oclassz00_4291 =
													VECTOR_REF(BgL_arg1954z00_4293, BgL_arg1955z00_4294);
											}
											{	/* Llib/thread.scm 326 */
												bool_t BgL__ortest_1149z00_4301;

												BgL__ortest_1149z00_4301 =
													(BgL_classz00_4269 == BgL_oclassz00_4291);
												if (BgL__ortest_1149z00_4301)
													{	/* Llib/thread.scm 326 */
														BgL_res2061z00_4287 = BgL__ortest_1149z00_4301;
													}
												else
													{	/* Llib/thread.scm 326 */
														long BgL_odepthz00_4302;

														{	/* Llib/thread.scm 326 */
															obj_t BgL_arg1942z00_4303;

															BgL_arg1942z00_4303 = (BgL_oclassz00_4291);
															BgL_odepthz00_4302 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4303);
														}
														if ((BgL_arg1948z00_4272 < BgL_odepthz00_4302))
															{	/* Llib/thread.scm 326 */
																obj_t BgL_arg1940z00_4307;

																{	/* Llib/thread.scm 326 */
																	obj_t BgL_arg1941z00_4308;

																	BgL_arg1941z00_4308 = (BgL_oclassz00_4291);
																	BgL_arg1940z00_4307 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4308,
																		BgL_arg1948z00_4272);
																}
																BgL_res2061z00_4287 =
																	(BgL_arg1940z00_4307 == BgL_classz00_4269);
															}
														else
															{	/* Llib/thread.scm 326 */
																BgL_res2061z00_4287 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2747z00_6132 = BgL_res2061z00_4287;
									}
							}
						else
							{	/* Llib/thread.scm 326 */
								BgL_test2747z00_6132 = ((bool_t) 0);
							}
					}
					if (BgL_test2747z00_6132)
						{	/* Llib/thread.scm 326 */
							BgL_auxz00_6131 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3755);
						}
					else
						{
							obj_t BgL_auxz00_6157;

							BgL_auxz00_6157 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(12844L), BGl_string2377z00zz__threadz00,
								BGl_string2215z00zz__threadz00, BgL_tbz00_3755);
							FAILURE(BgL_auxz00_6157, BFALSE, BFALSE);
						}
				}
				return BGl_tbzd2currentzd2threadz00zz__threadz00(BgL_auxz00_6131);
			}
		}

	}



/* tb-mutex-initialize! */
	BGL_EXPORTED_DEF obj_t
		BGl_tbzd2mutexzd2initializa7ez12zb5zz__threadz00
		(BgL_threadzd2backendzd2_bglt BgL_tbz00_15, obj_t BgL_mutexz00_16)
	{
		{	/* Llib/thread.scm 350 */
			{	/* Llib/thread.scm 350 */
				obj_t BgL_method1186z00_1646;

				{	/* Llib/thread.scm 350 */
					obj_t BgL_res1978z00_2613;

					{	/* Llib/thread.scm 350 */
						long BgL_objzd2classzd2numz00_2584;

						BgL_objzd2classzd2numz00_2584 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_tbz00_15));
						{	/* Llib/thread.scm 350 */
							obj_t BgL_arg1949z00_2585;

							BgL_arg1949z00_2585 =
								PROCEDURE_REF
								(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 350 */
								int BgL_offsetz00_2588;

								BgL_offsetz00_2588 = (int) (BgL_objzd2classzd2numz00_2584);
								{	/* Llib/thread.scm 350 */
									long BgL_offsetz00_2589;

									BgL_offsetz00_2589 =
										((long) (BgL_offsetz00_2588) - OBJECT_TYPE);
									{	/* Llib/thread.scm 350 */
										long BgL_modz00_2590;

										BgL_modz00_2590 =
											(BgL_offsetz00_2589 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 350 */
											long BgL_restz00_2592;

											BgL_restz00_2592 =
												(BgL_offsetz00_2589 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 350 */

												{	/* Llib/thread.scm 350 */
													obj_t BgL_bucketz00_2594;

													BgL_bucketz00_2594 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2585), BgL_modz00_2590);
													BgL_res1978z00_2613 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2594), BgL_restz00_2592);
					}}}}}}}}
					BgL_method1186z00_1646 = BgL_res1978z00_2613;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1186z00_1646,
					((obj_t) BgL_tbz00_15), BgL_mutexz00_16);
			}
		}

	}



/* &tb-mutex-initialize! */
	obj_t BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00(obj_t
		BgL_envz00_3756, obj_t BgL_tbz00_3757, obj_t BgL_mutexz00_3758)
	{
		{	/* Llib/thread.scm 350 */
			{	/* Llib/thread.scm 350 */
				obj_t BgL_auxz00_6223;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_6193;

				if (BGL_MUTEXP(BgL_mutexz00_3758))
					{	/* Llib/thread.scm 350 */
						BgL_auxz00_6223 = BgL_mutexz00_3758;
					}
				else
					{
						obj_t BgL_auxz00_6226;

						BgL_auxz00_6226 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(14029L), BGl_string2378z00zz__threadz00,
							BGl_string2229z00zz__threadz00, BgL_mutexz00_3758);
						FAILURE(BgL_auxz00_6226, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 350 */
					bool_t BgL_test2752z00_6194;

					{	/* Llib/thread.scm 350 */
						obj_t BgL_classz00_4309;

						BgL_classz00_4309 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3757))
							{	/* Llib/thread.scm 350 */
								BgL_objectz00_bglt BgL_arg1947z00_4311;
								long BgL_arg1948z00_4312;

								BgL_arg1947z00_4311 = (BgL_objectz00_bglt) (BgL_tbz00_3757);
								BgL_arg1948z00_4312 = BGL_CLASS_DEPTH(BgL_classz00_4309);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 350 */
										long BgL_idxz00_4320;

										BgL_idxz00_4320 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4311);
										{	/* Llib/thread.scm 350 */
											obj_t BgL_arg1938z00_4321;

											{	/* Llib/thread.scm 350 */
												long BgL_arg1939z00_4322;

												BgL_arg1939z00_4322 =
													(BgL_idxz00_4320 + BgL_arg1948z00_4312);
												BgL_arg1938z00_4321 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4322);
											}
											BgL_test2752z00_6194 =
												(BgL_arg1938z00_4321 == BgL_classz00_4309);
									}}
								else
									{	/* Llib/thread.scm 350 */
										bool_t BgL_res2061z00_4327;

										{	/* Llib/thread.scm 350 */
											obj_t BgL_oclassz00_4331;

											{	/* Llib/thread.scm 350 */
												obj_t BgL_arg1954z00_4333;
												long BgL_arg1955z00_4334;

												BgL_arg1954z00_4333 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 350 */
													long BgL_arg1956z00_4335;

													BgL_arg1956z00_4335 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4311);
													BgL_arg1955z00_4334 =
														(BgL_arg1956z00_4335 - OBJECT_TYPE);
												}
												BgL_oclassz00_4331 =
													VECTOR_REF(BgL_arg1954z00_4333, BgL_arg1955z00_4334);
											}
											{	/* Llib/thread.scm 350 */
												bool_t BgL__ortest_1149z00_4341;

												BgL__ortest_1149z00_4341 =
													(BgL_classz00_4309 == BgL_oclassz00_4331);
												if (BgL__ortest_1149z00_4341)
													{	/* Llib/thread.scm 350 */
														BgL_res2061z00_4327 = BgL__ortest_1149z00_4341;
													}
												else
													{	/* Llib/thread.scm 350 */
														long BgL_odepthz00_4342;

														{	/* Llib/thread.scm 350 */
															obj_t BgL_arg1942z00_4343;

															BgL_arg1942z00_4343 = (BgL_oclassz00_4331);
															BgL_odepthz00_4342 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4343);
														}
														if ((BgL_arg1948z00_4312 < BgL_odepthz00_4342))
															{	/* Llib/thread.scm 350 */
																obj_t BgL_arg1940z00_4347;

																{	/* Llib/thread.scm 350 */
																	obj_t BgL_arg1941z00_4348;

																	BgL_arg1941z00_4348 = (BgL_oclassz00_4331);
																	BgL_arg1940z00_4347 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4348,
																		BgL_arg1948z00_4312);
																}
																BgL_res2061z00_4327 =
																	(BgL_arg1940z00_4347 == BgL_classz00_4309);
															}
														else
															{	/* Llib/thread.scm 350 */
																BgL_res2061z00_4327 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2752z00_6194 = BgL_res2061z00_4327;
									}
							}
						else
							{	/* Llib/thread.scm 350 */
								BgL_test2752z00_6194 = ((bool_t) 0);
							}
					}
					if (BgL_test2752z00_6194)
						{	/* Llib/thread.scm 350 */
							BgL_auxz00_6193 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3757);
						}
					else
						{
							obj_t BgL_auxz00_6219;

							BgL_auxz00_6219 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(14029L), BGl_string2378z00zz__threadz00,
								BGl_string2215z00zz__threadz00, BgL_tbz00_3757);
							FAILURE(BgL_auxz00_6219, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2mutexzd2initializa7ez12zb5zz__threadz00(BgL_auxz00_6193,
					BgL_auxz00_6223);
			}
		}

	}



/* tb-condvar-initialize! */
	BGL_EXPORTED_DEF obj_t
		BGl_tbzd2condvarzd2initializa7ez12zb5zz__threadz00
		(BgL_threadzd2backendzd2_bglt BgL_tbz00_17, obj_t BgL_condvarz00_18)
	{
		{	/* Llib/thread.scm 355 */
			{	/* Llib/thread.scm 355 */
				obj_t BgL_method1188z00_1647;

				{	/* Llib/thread.scm 355 */
					obj_t BgL_res1983z00_2644;

					{	/* Llib/thread.scm 355 */
						long BgL_objzd2classzd2numz00_2615;

						BgL_objzd2classzd2numz00_2615 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_tbz00_17));
						{	/* Llib/thread.scm 355 */
							obj_t BgL_arg1949z00_2616;

							BgL_arg1949z00_2616 =
								PROCEDURE_REF
								(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 355 */
								int BgL_offsetz00_2619;

								BgL_offsetz00_2619 = (int) (BgL_objzd2classzd2numz00_2615);
								{	/* Llib/thread.scm 355 */
									long BgL_offsetz00_2620;

									BgL_offsetz00_2620 =
										((long) (BgL_offsetz00_2619) - OBJECT_TYPE);
									{	/* Llib/thread.scm 355 */
										long BgL_modz00_2621;

										BgL_modz00_2621 =
											(BgL_offsetz00_2620 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 355 */
											long BgL_restz00_2623;

											BgL_restz00_2623 =
												(BgL_offsetz00_2620 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 355 */

												{	/* Llib/thread.scm 355 */
													obj_t BgL_bucketz00_2625;

													BgL_bucketz00_2625 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2616), BgL_modz00_2621);
													BgL_res1983z00_2644 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2625), BgL_restz00_2623);
					}}}}}}}}
					BgL_method1188z00_1647 = BgL_res1983z00_2644;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1188z00_1647,
					((obj_t) BgL_tbz00_17), BgL_condvarz00_18);
			}
		}

	}



/* &tb-condvar-initialize! */
	obj_t BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00(obj_t
		BgL_envz00_3759, obj_t BgL_tbz00_3760, obj_t BgL_condvarz00_3761)
	{
		{	/* Llib/thread.scm 355 */
			{	/* Llib/thread.scm 355 */
				obj_t BgL_auxz00_6292;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_6262;

				if (BGL_CONDVARP(BgL_condvarz00_3761))
					{	/* Llib/thread.scm 355 */
						BgL_auxz00_6292 = BgL_condvarz00_3761;
					}
				else
					{
						obj_t BgL_auxz00_6295;

						BgL_auxz00_6295 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(14317L), BGl_string2379z00zz__threadz00,
							BGl_string2244z00zz__threadz00, BgL_condvarz00_3761);
						FAILURE(BgL_auxz00_6295, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 355 */
					bool_t BgL_test2758z00_6263;

					{	/* Llib/thread.scm 355 */
						obj_t BgL_classz00_4349;

						BgL_classz00_4349 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3760))
							{	/* Llib/thread.scm 355 */
								BgL_objectz00_bglt BgL_arg1947z00_4351;
								long BgL_arg1948z00_4352;

								BgL_arg1947z00_4351 = (BgL_objectz00_bglt) (BgL_tbz00_3760);
								BgL_arg1948z00_4352 = BGL_CLASS_DEPTH(BgL_classz00_4349);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 355 */
										long BgL_idxz00_4360;

										BgL_idxz00_4360 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4351);
										{	/* Llib/thread.scm 355 */
											obj_t BgL_arg1938z00_4361;

											{	/* Llib/thread.scm 355 */
												long BgL_arg1939z00_4362;

												BgL_arg1939z00_4362 =
													(BgL_idxz00_4360 + BgL_arg1948z00_4352);
												BgL_arg1938z00_4361 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4362);
											}
											BgL_test2758z00_6263 =
												(BgL_arg1938z00_4361 == BgL_classz00_4349);
									}}
								else
									{	/* Llib/thread.scm 355 */
										bool_t BgL_res2061z00_4367;

										{	/* Llib/thread.scm 355 */
											obj_t BgL_oclassz00_4371;

											{	/* Llib/thread.scm 355 */
												obj_t BgL_arg1954z00_4373;
												long BgL_arg1955z00_4374;

												BgL_arg1954z00_4373 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 355 */
													long BgL_arg1956z00_4375;

													BgL_arg1956z00_4375 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4351);
													BgL_arg1955z00_4374 =
														(BgL_arg1956z00_4375 - OBJECT_TYPE);
												}
												BgL_oclassz00_4371 =
													VECTOR_REF(BgL_arg1954z00_4373, BgL_arg1955z00_4374);
											}
											{	/* Llib/thread.scm 355 */
												bool_t BgL__ortest_1149z00_4381;

												BgL__ortest_1149z00_4381 =
													(BgL_classz00_4349 == BgL_oclassz00_4371);
												if (BgL__ortest_1149z00_4381)
													{	/* Llib/thread.scm 355 */
														BgL_res2061z00_4367 = BgL__ortest_1149z00_4381;
													}
												else
													{	/* Llib/thread.scm 355 */
														long BgL_odepthz00_4382;

														{	/* Llib/thread.scm 355 */
															obj_t BgL_arg1942z00_4383;

															BgL_arg1942z00_4383 = (BgL_oclassz00_4371);
															BgL_odepthz00_4382 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4383);
														}
														if ((BgL_arg1948z00_4352 < BgL_odepthz00_4382))
															{	/* Llib/thread.scm 355 */
																obj_t BgL_arg1940z00_4387;

																{	/* Llib/thread.scm 355 */
																	obj_t BgL_arg1941z00_4388;

																	BgL_arg1941z00_4388 = (BgL_oclassz00_4371);
																	BgL_arg1940z00_4387 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4388,
																		BgL_arg1948z00_4352);
																}
																BgL_res2061z00_4367 =
																	(BgL_arg1940z00_4387 == BgL_classz00_4349);
															}
														else
															{	/* Llib/thread.scm 355 */
																BgL_res2061z00_4367 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2758z00_6263 = BgL_res2061z00_4367;
									}
							}
						else
							{	/* Llib/thread.scm 355 */
								BgL_test2758z00_6263 = ((bool_t) 0);
							}
					}
					if (BgL_test2758z00_6263)
						{	/* Llib/thread.scm 355 */
							BgL_auxz00_6262 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3760);
						}
					else
						{
							obj_t BgL_auxz00_6288;

							BgL_auxz00_6288 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(14317L), BGl_string2379z00zz__threadz00,
								BGl_string2215z00zz__threadz00, BgL_tbz00_3760);
							FAILURE(BgL_auxz00_6288, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2condvarzd2initializa7ez12zb5zz__threadz00(BgL_auxz00_6262,
					BgL_auxz00_6292);
			}
		}

	}



/* thread-initialize! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2initializa7ez12z67zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_26)
	{
		{	/* Llib/thread.scm 384 */
			{	/* Llib/thread.scm 384 */
				obj_t BgL_method1196z00_1648;

				{	/* Llib/thread.scm 384 */
					obj_t BgL_res1988z00_2675;

					{	/* Llib/thread.scm 384 */
						long BgL_objzd2classzd2numz00_2646;

						BgL_objzd2classzd2numz00_2646 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_26));
						{	/* Llib/thread.scm 384 */
							obj_t BgL_arg1949z00_2647;

							BgL_arg1949z00_2647 =
								PROCEDURE_REF
								(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 384 */
								int BgL_offsetz00_2650;

								BgL_offsetz00_2650 = (int) (BgL_objzd2classzd2numz00_2646);
								{	/* Llib/thread.scm 384 */
									long BgL_offsetz00_2651;

									BgL_offsetz00_2651 =
										((long) (BgL_offsetz00_2650) - OBJECT_TYPE);
									{	/* Llib/thread.scm 384 */
										long BgL_modz00_2652;

										BgL_modz00_2652 =
											(BgL_offsetz00_2651 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 384 */
											long BgL_restz00_2654;

											BgL_restz00_2654 =
												(BgL_offsetz00_2651 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 384 */

												{	/* Llib/thread.scm 384 */
													obj_t BgL_bucketz00_2656;

													BgL_bucketz00_2656 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2647), BgL_modz00_2652);
													BgL_res1988z00_2675 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2656), BgL_restz00_2654);
					}}}}}}}}
					BgL_method1196z00_1648 = BgL_res1988z00_2675;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1196z00_1648, ((obj_t) BgL_thz00_26));
			}
		}

	}



/* &thread-initialize! */
	obj_t BGl_z62threadzd2initializa7ez12z05zz__threadz00(obj_t BgL_envz00_3680,
		obj_t BgL_thz00_3681)
	{
		{	/* Llib/thread.scm 384 */
			{	/* Llib/thread.scm 384 */
				BgL_threadz00_bglt BgL_auxz00_6330;

				{	/* Llib/thread.scm 384 */
					bool_t BgL_test2764z00_6331;

					{	/* Llib/thread.scm 384 */
						obj_t BgL_classz00_4389;

						BgL_classz00_4389 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3681))
							{	/* Llib/thread.scm 384 */
								BgL_objectz00_bglt BgL_arg1947z00_4391;
								long BgL_arg1948z00_4392;

								BgL_arg1947z00_4391 = (BgL_objectz00_bglt) (BgL_thz00_3681);
								BgL_arg1948z00_4392 = BGL_CLASS_DEPTH(BgL_classz00_4389);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 384 */
										long BgL_idxz00_4400;

										BgL_idxz00_4400 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4391);
										{	/* Llib/thread.scm 384 */
											obj_t BgL_arg1938z00_4401;

											{	/* Llib/thread.scm 384 */
												long BgL_arg1939z00_4402;

												BgL_arg1939z00_4402 =
													(BgL_idxz00_4400 + BgL_arg1948z00_4392);
												BgL_arg1938z00_4401 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4402);
											}
											BgL_test2764z00_6331 =
												(BgL_arg1938z00_4401 == BgL_classz00_4389);
									}}
								else
									{	/* Llib/thread.scm 384 */
										bool_t BgL_res2061z00_4407;

										{	/* Llib/thread.scm 384 */
											obj_t BgL_oclassz00_4411;

											{	/* Llib/thread.scm 384 */
												obj_t BgL_arg1954z00_4413;
												long BgL_arg1955z00_4414;

												BgL_arg1954z00_4413 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 384 */
													long BgL_arg1956z00_4415;

													BgL_arg1956z00_4415 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4391);
													BgL_arg1955z00_4414 =
														(BgL_arg1956z00_4415 - OBJECT_TYPE);
												}
												BgL_oclassz00_4411 =
													VECTOR_REF(BgL_arg1954z00_4413, BgL_arg1955z00_4414);
											}
											{	/* Llib/thread.scm 384 */
												bool_t BgL__ortest_1149z00_4421;

												BgL__ortest_1149z00_4421 =
													(BgL_classz00_4389 == BgL_oclassz00_4411);
												if (BgL__ortest_1149z00_4421)
													{	/* Llib/thread.scm 384 */
														BgL_res2061z00_4407 = BgL__ortest_1149z00_4421;
													}
												else
													{	/* Llib/thread.scm 384 */
														long BgL_odepthz00_4422;

														{	/* Llib/thread.scm 384 */
															obj_t BgL_arg1942z00_4423;

															BgL_arg1942z00_4423 = (BgL_oclassz00_4411);
															BgL_odepthz00_4422 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4423);
														}
														if ((BgL_arg1948z00_4392 < BgL_odepthz00_4422))
															{	/* Llib/thread.scm 384 */
																obj_t BgL_arg1940z00_4427;

																{	/* Llib/thread.scm 384 */
																	obj_t BgL_arg1941z00_4428;

																	BgL_arg1941z00_4428 = (BgL_oclassz00_4411);
																	BgL_arg1940z00_4427 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4428,
																		BgL_arg1948z00_4392);
																}
																BgL_res2061z00_4407 =
																	(BgL_arg1940z00_4427 == BgL_classz00_4389);
															}
														else
															{	/* Llib/thread.scm 384 */
																BgL_res2061z00_4407 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2764z00_6331 = BgL_res2061z00_4407;
									}
							}
						else
							{	/* Llib/thread.scm 384 */
								BgL_test2764z00_6331 = ((bool_t) 0);
							}
					}
					if (BgL_test2764z00_6331)
						{	/* Llib/thread.scm 384 */
							BgL_auxz00_6330 = ((BgL_threadz00_bglt) BgL_thz00_3681);
						}
					else
						{
							obj_t BgL_auxz00_6356;

							BgL_auxz00_6356 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(15868L), BGl_string2380z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3681);
							FAILURE(BgL_auxz00_6356, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2initializa7ez12z67zz__threadz00(BgL_auxz00_6330);
			}
		}

	}



/* thread-start! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2startz12zc0zz__threadz00(BgL_threadz00_bglt BgL_thz00_27,
		obj_t BgL_scz00_28)
	{
		{	/* Llib/thread.scm 390 */
			{	/* Llib/thread.scm 390 */
				obj_t BgL_method1198z00_1649;

				{	/* Llib/thread.scm 390 */
					obj_t BgL_res1993z00_2706;

					{	/* Llib/thread.scm 390 */
						long BgL_objzd2classzd2numz00_2677;

						BgL_objzd2classzd2numz00_2677 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_27));
						{	/* Llib/thread.scm 390 */
							obj_t BgL_arg1949z00_2678;

							BgL_arg1949z00_2678 =
								PROCEDURE_REF(BGl_threadzd2startz12zd2envz12zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 390 */
								int BgL_offsetz00_2681;

								BgL_offsetz00_2681 = (int) (BgL_objzd2classzd2numz00_2677);
								{	/* Llib/thread.scm 390 */
									long BgL_offsetz00_2682;

									BgL_offsetz00_2682 =
										((long) (BgL_offsetz00_2681) - OBJECT_TYPE);
									{	/* Llib/thread.scm 390 */
										long BgL_modz00_2683;

										BgL_modz00_2683 =
											(BgL_offsetz00_2682 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 390 */
											long BgL_restz00_2685;

											BgL_restz00_2685 =
												(BgL_offsetz00_2682 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 390 */

												{	/* Llib/thread.scm 390 */
													obj_t BgL_bucketz00_2687;

													BgL_bucketz00_2687 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2678), BgL_modz00_2683);
													BgL_res1993z00_2706 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2687), BgL_restz00_2685);
					}}}}}}}}
					BgL_method1198z00_1649 = BgL_res1993z00_2706;
				}
				{	/* Llib/thread.scm 390 */
					obj_t BgL_auxz00_6386;

					{	/* Llib/thread.scm 390 */
						obj_t BgL_list1524z00_1650;

						BgL_list1524z00_1650 = MAKE_YOUNG_PAIR(BgL_scz00_28, BNIL);
						BgL_auxz00_6386 =
							BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(
							((obj_t) BgL_thz00_27), BgL_list1524z00_1650);
					}
					return apply(BgL_method1198z00_1649, BgL_auxz00_6386);
				}
			}
		}

	}



/* &thread-start! */
	obj_t BGl_z62threadzd2startz12za2zz__threadz00(obj_t BgL_envz00_3762,
		obj_t BgL_thz00_3763, obj_t BgL_scz00_3764)
	{
		{	/* Llib/thread.scm 390 */
			{	/* Llib/thread.scm 390 */
				BgL_threadz00_bglt BgL_auxz00_6391;

				{	/* Llib/thread.scm 390 */
					bool_t BgL_test2769z00_6392;

					{	/* Llib/thread.scm 390 */
						obj_t BgL_classz00_4429;

						BgL_classz00_4429 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3763))
							{	/* Llib/thread.scm 390 */
								BgL_objectz00_bglt BgL_arg1947z00_4431;
								long BgL_arg1948z00_4432;

								BgL_arg1947z00_4431 = (BgL_objectz00_bglt) (BgL_thz00_3763);
								BgL_arg1948z00_4432 = BGL_CLASS_DEPTH(BgL_classz00_4429);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 390 */
										long BgL_idxz00_4440;

										BgL_idxz00_4440 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4431);
										{	/* Llib/thread.scm 390 */
											obj_t BgL_arg1938z00_4441;

											{	/* Llib/thread.scm 390 */
												long BgL_arg1939z00_4442;

												BgL_arg1939z00_4442 =
													(BgL_idxz00_4440 + BgL_arg1948z00_4432);
												BgL_arg1938z00_4441 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4442);
											}
											BgL_test2769z00_6392 =
												(BgL_arg1938z00_4441 == BgL_classz00_4429);
									}}
								else
									{	/* Llib/thread.scm 390 */
										bool_t BgL_res2061z00_4447;

										{	/* Llib/thread.scm 390 */
											obj_t BgL_oclassz00_4451;

											{	/* Llib/thread.scm 390 */
												obj_t BgL_arg1954z00_4453;
												long BgL_arg1955z00_4454;

												BgL_arg1954z00_4453 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 390 */
													long BgL_arg1956z00_4455;

													BgL_arg1956z00_4455 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4431);
													BgL_arg1955z00_4454 =
														(BgL_arg1956z00_4455 - OBJECT_TYPE);
												}
												BgL_oclassz00_4451 =
													VECTOR_REF(BgL_arg1954z00_4453, BgL_arg1955z00_4454);
											}
											{	/* Llib/thread.scm 390 */
												bool_t BgL__ortest_1149z00_4461;

												BgL__ortest_1149z00_4461 =
													(BgL_classz00_4429 == BgL_oclassz00_4451);
												if (BgL__ortest_1149z00_4461)
													{	/* Llib/thread.scm 390 */
														BgL_res2061z00_4447 = BgL__ortest_1149z00_4461;
													}
												else
													{	/* Llib/thread.scm 390 */
														long BgL_odepthz00_4462;

														{	/* Llib/thread.scm 390 */
															obj_t BgL_arg1942z00_4463;

															BgL_arg1942z00_4463 = (BgL_oclassz00_4451);
															BgL_odepthz00_4462 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4463);
														}
														if ((BgL_arg1948z00_4432 < BgL_odepthz00_4462))
															{	/* Llib/thread.scm 390 */
																obj_t BgL_arg1940z00_4467;

																{	/* Llib/thread.scm 390 */
																	obj_t BgL_arg1941z00_4468;

																	BgL_arg1941z00_4468 = (BgL_oclassz00_4451);
																	BgL_arg1940z00_4467 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4468,
																		BgL_arg1948z00_4432);
																}
																BgL_res2061z00_4447 =
																	(BgL_arg1940z00_4467 == BgL_classz00_4429);
															}
														else
															{	/* Llib/thread.scm 390 */
																BgL_res2061z00_4447 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2769z00_6392 = BgL_res2061z00_4447;
									}
							}
						else
							{	/* Llib/thread.scm 390 */
								BgL_test2769z00_6392 = ((bool_t) 0);
							}
					}
					if (BgL_test2769z00_6392)
						{	/* Llib/thread.scm 390 */
							BgL_auxz00_6391 = ((BgL_threadz00_bglt) BgL_thz00_3763);
						}
					else
						{
							obj_t BgL_auxz00_6417;

							BgL_auxz00_6417 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(16146L), BGl_string2381z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3763);
							FAILURE(BgL_auxz00_6417, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2startz12zc0zz__threadz00(BgL_auxz00_6391,
					BgL_scz00_3764);
			}
		}

	}



/* thread-start-joinable! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2startzd2joinablez12z12zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_29)
	{
		{	/* Llib/thread.scm 395 */
			{	/* Llib/thread.scm 395 */
				obj_t BgL_method1200z00_1651;

				{	/* Llib/thread.scm 395 */
					obj_t BgL_res1998z00_2737;

					{	/* Llib/thread.scm 395 */
						long BgL_objzd2classzd2numz00_2708;

						BgL_objzd2classzd2numz00_2708 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_29));
						{	/* Llib/thread.scm 395 */
							obj_t BgL_arg1949z00_2709;

							BgL_arg1949z00_2709 =
								PROCEDURE_REF
								(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 395 */
								int BgL_offsetz00_2712;

								BgL_offsetz00_2712 = (int) (BgL_objzd2classzd2numz00_2708);
								{	/* Llib/thread.scm 395 */
									long BgL_offsetz00_2713;

									BgL_offsetz00_2713 =
										((long) (BgL_offsetz00_2712) - OBJECT_TYPE);
									{	/* Llib/thread.scm 395 */
										long BgL_modz00_2714;

										BgL_modz00_2714 =
											(BgL_offsetz00_2713 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 395 */
											long BgL_restz00_2716;

											BgL_restz00_2716 =
												(BgL_offsetz00_2713 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 395 */

												{	/* Llib/thread.scm 395 */
													obj_t BgL_bucketz00_2718;

													BgL_bucketz00_2718 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2709), BgL_modz00_2714);
													BgL_res1998z00_2737 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2718), BgL_restz00_2716);
					}}}}}}}}
					BgL_method1200z00_1651 = BgL_res1998z00_2737;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1200z00_1651, ((obj_t) BgL_thz00_29));
			}
		}

	}



/* &thread-start-joinable! */
	obj_t BGl_z62threadzd2startzd2joinablez12z70zz__threadz00(obj_t
		BgL_envz00_3765, obj_t BgL_thz00_3766)
	{
		{	/* Llib/thread.scm 395 */
			{	/* Llib/thread.scm 395 */
				BgL_threadz00_bglt BgL_auxz00_6452;

				{	/* Llib/thread.scm 395 */
					bool_t BgL_test2774z00_6453;

					{	/* Llib/thread.scm 395 */
						obj_t BgL_classz00_4469;

						BgL_classz00_4469 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3766))
							{	/* Llib/thread.scm 395 */
								BgL_objectz00_bglt BgL_arg1947z00_4471;
								long BgL_arg1948z00_4472;

								BgL_arg1947z00_4471 = (BgL_objectz00_bglt) (BgL_thz00_3766);
								BgL_arg1948z00_4472 = BGL_CLASS_DEPTH(BgL_classz00_4469);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 395 */
										long BgL_idxz00_4480;

										BgL_idxz00_4480 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4471);
										{	/* Llib/thread.scm 395 */
											obj_t BgL_arg1938z00_4481;

											{	/* Llib/thread.scm 395 */
												long BgL_arg1939z00_4482;

												BgL_arg1939z00_4482 =
													(BgL_idxz00_4480 + BgL_arg1948z00_4472);
												BgL_arg1938z00_4481 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4482);
											}
											BgL_test2774z00_6453 =
												(BgL_arg1938z00_4481 == BgL_classz00_4469);
									}}
								else
									{	/* Llib/thread.scm 395 */
										bool_t BgL_res2061z00_4487;

										{	/* Llib/thread.scm 395 */
											obj_t BgL_oclassz00_4491;

											{	/* Llib/thread.scm 395 */
												obj_t BgL_arg1954z00_4493;
												long BgL_arg1955z00_4494;

												BgL_arg1954z00_4493 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 395 */
													long BgL_arg1956z00_4495;

													BgL_arg1956z00_4495 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4471);
													BgL_arg1955z00_4494 =
														(BgL_arg1956z00_4495 - OBJECT_TYPE);
												}
												BgL_oclassz00_4491 =
													VECTOR_REF(BgL_arg1954z00_4493, BgL_arg1955z00_4494);
											}
											{	/* Llib/thread.scm 395 */
												bool_t BgL__ortest_1149z00_4501;

												BgL__ortest_1149z00_4501 =
													(BgL_classz00_4469 == BgL_oclassz00_4491);
												if (BgL__ortest_1149z00_4501)
													{	/* Llib/thread.scm 395 */
														BgL_res2061z00_4487 = BgL__ortest_1149z00_4501;
													}
												else
													{	/* Llib/thread.scm 395 */
														long BgL_odepthz00_4502;

														{	/* Llib/thread.scm 395 */
															obj_t BgL_arg1942z00_4503;

															BgL_arg1942z00_4503 = (BgL_oclassz00_4491);
															BgL_odepthz00_4502 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4503);
														}
														if ((BgL_arg1948z00_4472 < BgL_odepthz00_4502))
															{	/* Llib/thread.scm 395 */
																obj_t BgL_arg1940z00_4507;

																{	/* Llib/thread.scm 395 */
																	obj_t BgL_arg1941z00_4508;

																	BgL_arg1941z00_4508 = (BgL_oclassz00_4491);
																	BgL_arg1940z00_4507 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4508,
																		BgL_arg1948z00_4472);
																}
																BgL_res2061z00_4487 =
																	(BgL_arg1940z00_4507 == BgL_classz00_4469);
															}
														else
															{	/* Llib/thread.scm 395 */
																BgL_res2061z00_4487 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2774z00_6453 = BgL_res2061z00_4487;
									}
							}
						else
							{	/* Llib/thread.scm 395 */
								BgL_test2774z00_6453 = ((bool_t) 0);
							}
					}
					if (BgL_test2774z00_6453)
						{	/* Llib/thread.scm 395 */
							BgL_auxz00_6452 = ((BgL_threadz00_bglt) BgL_thz00_3766);
						}
					else
						{
							obj_t BgL_auxz00_6478;

							BgL_auxz00_6478 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(16418L), BGl_string2382z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3766);
							FAILURE(BgL_auxz00_6478, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2startzd2joinablez12z12zz__threadz00(BgL_auxz00_6452);
			}
		}

	}



/* thread-join! */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2joinz12zc0zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_30, obj_t BgL_timeoutz00_31)
	{
		{	/* Llib/thread.scm 400 */
			{	/* Llib/thread.scm 400 */
				obj_t BgL_method1202z00_1652;

				{	/* Llib/thread.scm 400 */
					obj_t BgL_res2003z00_2768;

					{	/* Llib/thread.scm 400 */
						long BgL_objzd2classzd2numz00_2739;

						BgL_objzd2classzd2numz00_2739 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_30));
						{	/* Llib/thread.scm 400 */
							obj_t BgL_arg1949z00_2740;

							BgL_arg1949z00_2740 =
								PROCEDURE_REF(BGl_threadzd2joinz12zd2envz12zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 400 */
								int BgL_offsetz00_2743;

								BgL_offsetz00_2743 = (int) (BgL_objzd2classzd2numz00_2739);
								{	/* Llib/thread.scm 400 */
									long BgL_offsetz00_2744;

									BgL_offsetz00_2744 =
										((long) (BgL_offsetz00_2743) - OBJECT_TYPE);
									{	/* Llib/thread.scm 400 */
										long BgL_modz00_2745;

										BgL_modz00_2745 =
											(BgL_offsetz00_2744 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 400 */
											long BgL_restz00_2747;

											BgL_restz00_2747 =
												(BgL_offsetz00_2744 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 400 */

												{	/* Llib/thread.scm 400 */
													obj_t BgL_bucketz00_2749;

													BgL_bucketz00_2749 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2740), BgL_modz00_2745);
													BgL_res2003z00_2768 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2749), BgL_restz00_2747);
					}}}}}}}}
					BgL_method1202z00_1652 = BgL_res2003z00_2768;
				}
				{	/* Llib/thread.scm 400 */
					obj_t BgL_auxz00_6508;

					{	/* Llib/thread.scm 400 */
						obj_t BgL_list1525z00_1653;

						BgL_list1525z00_1653 = MAKE_YOUNG_PAIR(BgL_timeoutz00_31, BNIL);
						BgL_auxz00_6508 =
							BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(
							((obj_t) BgL_thz00_30), BgL_list1525z00_1653);
					}
					return apply(BgL_method1202z00_1652, BgL_auxz00_6508);
				}
			}
		}

	}



/* &thread-join! */
	obj_t BGl_z62threadzd2joinz12za2zz__threadz00(obj_t BgL_envz00_3767,
		obj_t BgL_thz00_3768, obj_t BgL_timeoutz00_3769)
	{
		{	/* Llib/thread.scm 400 */
			{	/* Llib/thread.scm 400 */
				BgL_threadz00_bglt BgL_auxz00_6513;

				{	/* Llib/thread.scm 400 */
					bool_t BgL_test2779z00_6514;

					{	/* Llib/thread.scm 400 */
						obj_t BgL_classz00_4509;

						BgL_classz00_4509 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3768))
							{	/* Llib/thread.scm 400 */
								BgL_objectz00_bglt BgL_arg1947z00_4511;
								long BgL_arg1948z00_4512;

								BgL_arg1947z00_4511 = (BgL_objectz00_bglt) (BgL_thz00_3768);
								BgL_arg1948z00_4512 = BGL_CLASS_DEPTH(BgL_classz00_4509);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 400 */
										long BgL_idxz00_4520;

										BgL_idxz00_4520 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4511);
										{	/* Llib/thread.scm 400 */
											obj_t BgL_arg1938z00_4521;

											{	/* Llib/thread.scm 400 */
												long BgL_arg1939z00_4522;

												BgL_arg1939z00_4522 =
													(BgL_idxz00_4520 + BgL_arg1948z00_4512);
												BgL_arg1938z00_4521 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4522);
											}
											BgL_test2779z00_6514 =
												(BgL_arg1938z00_4521 == BgL_classz00_4509);
									}}
								else
									{	/* Llib/thread.scm 400 */
										bool_t BgL_res2061z00_4527;

										{	/* Llib/thread.scm 400 */
											obj_t BgL_oclassz00_4531;

											{	/* Llib/thread.scm 400 */
												obj_t BgL_arg1954z00_4533;
												long BgL_arg1955z00_4534;

												BgL_arg1954z00_4533 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 400 */
													long BgL_arg1956z00_4535;

													BgL_arg1956z00_4535 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4511);
													BgL_arg1955z00_4534 =
														(BgL_arg1956z00_4535 - OBJECT_TYPE);
												}
												BgL_oclassz00_4531 =
													VECTOR_REF(BgL_arg1954z00_4533, BgL_arg1955z00_4534);
											}
											{	/* Llib/thread.scm 400 */
												bool_t BgL__ortest_1149z00_4541;

												BgL__ortest_1149z00_4541 =
													(BgL_classz00_4509 == BgL_oclassz00_4531);
												if (BgL__ortest_1149z00_4541)
													{	/* Llib/thread.scm 400 */
														BgL_res2061z00_4527 = BgL__ortest_1149z00_4541;
													}
												else
													{	/* Llib/thread.scm 400 */
														long BgL_odepthz00_4542;

														{	/* Llib/thread.scm 400 */
															obj_t BgL_arg1942z00_4543;

															BgL_arg1942z00_4543 = (BgL_oclassz00_4531);
															BgL_odepthz00_4542 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4543);
														}
														if ((BgL_arg1948z00_4512 < BgL_odepthz00_4542))
															{	/* Llib/thread.scm 400 */
																obj_t BgL_arg1940z00_4547;

																{	/* Llib/thread.scm 400 */
																	obj_t BgL_arg1941z00_4548;

																	BgL_arg1941z00_4548 = (BgL_oclassz00_4531);
																	BgL_arg1940z00_4547 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4548,
																		BgL_arg1948z00_4512);
																}
																BgL_res2061z00_4527 =
																	(BgL_arg1940z00_4547 == BgL_classz00_4509);
															}
														else
															{	/* Llib/thread.scm 400 */
																BgL_res2061z00_4527 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2779z00_6514 = BgL_res2061z00_4527;
									}
							}
						else
							{	/* Llib/thread.scm 400 */
								BgL_test2779z00_6514 = ((bool_t) 0);
							}
					}
					if (BgL_test2779z00_6514)
						{	/* Llib/thread.scm 400 */
							BgL_auxz00_6513 = ((BgL_threadz00_bglt) BgL_thz00_3768);
						}
					else
						{
							obj_t BgL_auxz00_6539;

							BgL_auxz00_6539 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(16694L), BGl_string2383z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3768);
							FAILURE(BgL_auxz00_6539, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2joinz12zc0zz__threadz00(BgL_auxz00_6513,
					BgL_timeoutz00_3769);
			}
		}

	}



/* thread-terminate! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2terminatez12zc0zz__threadz00(BgL_threadz00_bglt BgL_thz00_32)
	{
		{	/* Llib/thread.scm 405 */
			{	/* Llib/thread.scm 405 */
				obj_t BgL_method1204z00_1654;

				{	/* Llib/thread.scm 405 */
					obj_t BgL_res2008z00_2799;

					{	/* Llib/thread.scm 405 */
						long BgL_objzd2classzd2numz00_2770;

						BgL_objzd2classzd2numz00_2770 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_32));
						{	/* Llib/thread.scm 405 */
							obj_t BgL_arg1949z00_2771;

							BgL_arg1949z00_2771 =
								PROCEDURE_REF(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 405 */
								int BgL_offsetz00_2774;

								BgL_offsetz00_2774 = (int) (BgL_objzd2classzd2numz00_2770);
								{	/* Llib/thread.scm 405 */
									long BgL_offsetz00_2775;

									BgL_offsetz00_2775 =
										((long) (BgL_offsetz00_2774) - OBJECT_TYPE);
									{	/* Llib/thread.scm 405 */
										long BgL_modz00_2776;

										BgL_modz00_2776 =
											(BgL_offsetz00_2775 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 405 */
											long BgL_restz00_2778;

											BgL_restz00_2778 =
												(BgL_offsetz00_2775 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 405 */

												{	/* Llib/thread.scm 405 */
													obj_t BgL_bucketz00_2780;

													BgL_bucketz00_2780 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2771), BgL_modz00_2776);
													BgL_res2008z00_2799 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2780), BgL_restz00_2778);
					}}}}}}}}
					BgL_method1204z00_1654 = BgL_res2008z00_2799;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1204z00_1654, ((obj_t) BgL_thz00_32));
			}
		}

	}



/* &thread-terminate! */
	obj_t BGl_z62threadzd2terminatez12za2zz__threadz00(obj_t BgL_envz00_3770,
		obj_t BgL_thz00_3771)
	{
		{	/* Llib/thread.scm 405 */
			{	/* Llib/thread.scm 405 */
				BgL_threadz00_bglt BgL_auxz00_6574;

				{	/* Llib/thread.scm 405 */
					bool_t BgL_test2784z00_6575;

					{	/* Llib/thread.scm 405 */
						obj_t BgL_classz00_4549;

						BgL_classz00_4549 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3771))
							{	/* Llib/thread.scm 405 */
								BgL_objectz00_bglt BgL_arg1947z00_4551;
								long BgL_arg1948z00_4552;

								BgL_arg1947z00_4551 = (BgL_objectz00_bglt) (BgL_thz00_3771);
								BgL_arg1948z00_4552 = BGL_CLASS_DEPTH(BgL_classz00_4549);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 405 */
										long BgL_idxz00_4560;

										BgL_idxz00_4560 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4551);
										{	/* Llib/thread.scm 405 */
											obj_t BgL_arg1938z00_4561;

											{	/* Llib/thread.scm 405 */
												long BgL_arg1939z00_4562;

												BgL_arg1939z00_4562 =
													(BgL_idxz00_4560 + BgL_arg1948z00_4552);
												BgL_arg1938z00_4561 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4562);
											}
											BgL_test2784z00_6575 =
												(BgL_arg1938z00_4561 == BgL_classz00_4549);
									}}
								else
									{	/* Llib/thread.scm 405 */
										bool_t BgL_res2061z00_4567;

										{	/* Llib/thread.scm 405 */
											obj_t BgL_oclassz00_4571;

											{	/* Llib/thread.scm 405 */
												obj_t BgL_arg1954z00_4573;
												long BgL_arg1955z00_4574;

												BgL_arg1954z00_4573 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 405 */
													long BgL_arg1956z00_4575;

													BgL_arg1956z00_4575 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4551);
													BgL_arg1955z00_4574 =
														(BgL_arg1956z00_4575 - OBJECT_TYPE);
												}
												BgL_oclassz00_4571 =
													VECTOR_REF(BgL_arg1954z00_4573, BgL_arg1955z00_4574);
											}
											{	/* Llib/thread.scm 405 */
												bool_t BgL__ortest_1149z00_4581;

												BgL__ortest_1149z00_4581 =
													(BgL_classz00_4549 == BgL_oclassz00_4571);
												if (BgL__ortest_1149z00_4581)
													{	/* Llib/thread.scm 405 */
														BgL_res2061z00_4567 = BgL__ortest_1149z00_4581;
													}
												else
													{	/* Llib/thread.scm 405 */
														long BgL_odepthz00_4582;

														{	/* Llib/thread.scm 405 */
															obj_t BgL_arg1942z00_4583;

															BgL_arg1942z00_4583 = (BgL_oclassz00_4571);
															BgL_odepthz00_4582 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4583);
														}
														if ((BgL_arg1948z00_4552 < BgL_odepthz00_4582))
															{	/* Llib/thread.scm 405 */
																obj_t BgL_arg1940z00_4587;

																{	/* Llib/thread.scm 405 */
																	obj_t BgL_arg1941z00_4588;

																	BgL_arg1941z00_4588 = (BgL_oclassz00_4571);
																	BgL_arg1940z00_4587 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4588,
																		BgL_arg1948z00_4552);
																}
																BgL_res2061z00_4567 =
																	(BgL_arg1940z00_4587 == BgL_classz00_4549);
															}
														else
															{	/* Llib/thread.scm 405 */
																BgL_res2061z00_4567 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2784z00_6575 = BgL_res2061z00_4567;
									}
							}
						else
							{	/* Llib/thread.scm 405 */
								BgL_test2784z00_6575 = ((bool_t) 0);
							}
					}
					if (BgL_test2784z00_6575)
						{	/* Llib/thread.scm 405 */
							BgL_auxz00_6574 = ((BgL_threadz00_bglt) BgL_thz00_3771);
						}
					else
						{
							obj_t BgL_auxz00_6600;

							BgL_auxz00_6600 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(16970L), BGl_string2384z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3771);
							FAILURE(BgL_auxz00_6600, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2terminatez12zc0zz__threadz00(BgL_auxz00_6574);
			}
		}

	}



/* thread-kill! */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2killz12zc0zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_33, int BgL_nz00_34)
	{
		{	/* Llib/thread.scm 410 */
			{	/* Llib/thread.scm 410 */
				obj_t BgL_method1206z00_1655;

				{	/* Llib/thread.scm 410 */
					obj_t BgL_res2013z00_2830;

					{	/* Llib/thread.scm 410 */
						long BgL_objzd2classzd2numz00_2801;

						BgL_objzd2classzd2numz00_2801 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_33));
						{	/* Llib/thread.scm 410 */
							obj_t BgL_arg1949z00_2802;

							BgL_arg1949z00_2802 =
								PROCEDURE_REF(BGl_threadzd2killz12zd2envz12zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 410 */
								int BgL_offsetz00_2805;

								BgL_offsetz00_2805 = (int) (BgL_objzd2classzd2numz00_2801);
								{	/* Llib/thread.scm 410 */
									long BgL_offsetz00_2806;

									BgL_offsetz00_2806 =
										((long) (BgL_offsetz00_2805) - OBJECT_TYPE);
									{	/* Llib/thread.scm 410 */
										long BgL_modz00_2807;

										BgL_modz00_2807 =
											(BgL_offsetz00_2806 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 410 */
											long BgL_restz00_2809;

											BgL_restz00_2809 =
												(BgL_offsetz00_2806 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 410 */

												{	/* Llib/thread.scm 410 */
													obj_t BgL_bucketz00_2811;

													BgL_bucketz00_2811 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2802), BgL_modz00_2807);
													BgL_res2013z00_2830 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2811), BgL_restz00_2809);
					}}}}}}}}
					BgL_method1206z00_1655 = BgL_res2013z00_2830;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1206z00_1655,
					((obj_t) BgL_thz00_33), BINT(BgL_nz00_34));
			}
		}

	}



/* &thread-kill! */
	obj_t BGl_z62threadzd2killz12za2zz__threadz00(obj_t BgL_envz00_3772,
		obj_t BgL_thz00_3773, obj_t BgL_nz00_3774)
	{
		{	/* Llib/thread.scm 410 */
			{	/* Llib/thread.scm 410 */
				int BgL_auxz00_6667;
				BgL_threadz00_bglt BgL_auxz00_6637;

				{	/* Llib/thread.scm 410 */
					obj_t BgL_tmpz00_6668;

					if (INTEGERP(BgL_nz00_3774))
						{	/* Llib/thread.scm 410 */
							BgL_tmpz00_6668 = BgL_nz00_3774;
						}
					else
						{
							obj_t BgL_auxz00_6671;

							BgL_auxz00_6671 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(17241L), BGl_string2385z00zz__threadz00,
								BGl_string2235z00zz__threadz00, BgL_nz00_3774);
							FAILURE(BgL_auxz00_6671, BFALSE, BFALSE);
						}
					BgL_auxz00_6667 = CINT(BgL_tmpz00_6668);
				}
				{	/* Llib/thread.scm 410 */
					bool_t BgL_test2789z00_6638;

					{	/* Llib/thread.scm 410 */
						obj_t BgL_classz00_4589;

						BgL_classz00_4589 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3773))
							{	/* Llib/thread.scm 410 */
								BgL_objectz00_bglt BgL_arg1947z00_4591;
								long BgL_arg1948z00_4592;

								BgL_arg1947z00_4591 = (BgL_objectz00_bglt) (BgL_thz00_3773);
								BgL_arg1948z00_4592 = BGL_CLASS_DEPTH(BgL_classz00_4589);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 410 */
										long BgL_idxz00_4600;

										BgL_idxz00_4600 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4591);
										{	/* Llib/thread.scm 410 */
											obj_t BgL_arg1938z00_4601;

											{	/* Llib/thread.scm 410 */
												long BgL_arg1939z00_4602;

												BgL_arg1939z00_4602 =
													(BgL_idxz00_4600 + BgL_arg1948z00_4592);
												BgL_arg1938z00_4601 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4602);
											}
											BgL_test2789z00_6638 =
												(BgL_arg1938z00_4601 == BgL_classz00_4589);
									}}
								else
									{	/* Llib/thread.scm 410 */
										bool_t BgL_res2061z00_4607;

										{	/* Llib/thread.scm 410 */
											obj_t BgL_oclassz00_4611;

											{	/* Llib/thread.scm 410 */
												obj_t BgL_arg1954z00_4613;
												long BgL_arg1955z00_4614;

												BgL_arg1954z00_4613 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 410 */
													long BgL_arg1956z00_4615;

													BgL_arg1956z00_4615 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4591);
													BgL_arg1955z00_4614 =
														(BgL_arg1956z00_4615 - OBJECT_TYPE);
												}
												BgL_oclassz00_4611 =
													VECTOR_REF(BgL_arg1954z00_4613, BgL_arg1955z00_4614);
											}
											{	/* Llib/thread.scm 410 */
												bool_t BgL__ortest_1149z00_4621;

												BgL__ortest_1149z00_4621 =
													(BgL_classz00_4589 == BgL_oclassz00_4611);
												if (BgL__ortest_1149z00_4621)
													{	/* Llib/thread.scm 410 */
														BgL_res2061z00_4607 = BgL__ortest_1149z00_4621;
													}
												else
													{	/* Llib/thread.scm 410 */
														long BgL_odepthz00_4622;

														{	/* Llib/thread.scm 410 */
															obj_t BgL_arg1942z00_4623;

															BgL_arg1942z00_4623 = (BgL_oclassz00_4611);
															BgL_odepthz00_4622 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4623);
														}
														if ((BgL_arg1948z00_4592 < BgL_odepthz00_4622))
															{	/* Llib/thread.scm 410 */
																obj_t BgL_arg1940z00_4627;

																{	/* Llib/thread.scm 410 */
																	obj_t BgL_arg1941z00_4628;

																	BgL_arg1941z00_4628 = (BgL_oclassz00_4611);
																	BgL_arg1940z00_4627 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4628,
																		BgL_arg1948z00_4592);
																}
																BgL_res2061z00_4607 =
																	(BgL_arg1940z00_4627 == BgL_classz00_4589);
															}
														else
															{	/* Llib/thread.scm 410 */
																BgL_res2061z00_4607 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2789z00_6638 = BgL_res2061z00_4607;
									}
							}
						else
							{	/* Llib/thread.scm 410 */
								BgL_test2789z00_6638 = ((bool_t) 0);
							}
					}
					if (BgL_test2789z00_6638)
						{	/* Llib/thread.scm 410 */
							BgL_auxz00_6637 = ((BgL_threadz00_bglt) BgL_thz00_3773);
						}
					else
						{
							obj_t BgL_auxz00_6663;

							BgL_auxz00_6663 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(17241L), BGl_string2385z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3773);
							FAILURE(BgL_auxz00_6663, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2killz12zc0zz__threadz00(BgL_auxz00_6637,
					BgL_auxz00_6667);
			}
		}

	}



/* thread-specific */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2specificzd2zz__threadz00(BgL_threadz00_bglt BgL_thz00_35)
	{
		{	/* Llib/thread.scm 415 */
			{	/* Llib/thread.scm 415 */
				obj_t BgL_method1209z00_1656;

				{	/* Llib/thread.scm 415 */
					obj_t BgL_res2018z00_2861;

					{	/* Llib/thread.scm 415 */
						long BgL_objzd2classzd2numz00_2832;

						BgL_objzd2classzd2numz00_2832 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_35));
						{	/* Llib/thread.scm 415 */
							obj_t BgL_arg1949z00_2833;

							BgL_arg1949z00_2833 =
								PROCEDURE_REF(BGl_threadzd2specificzd2envz00zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 415 */
								int BgL_offsetz00_2836;

								BgL_offsetz00_2836 = (int) (BgL_objzd2classzd2numz00_2832);
								{	/* Llib/thread.scm 415 */
									long BgL_offsetz00_2837;

									BgL_offsetz00_2837 =
										((long) (BgL_offsetz00_2836) - OBJECT_TYPE);
									{	/* Llib/thread.scm 415 */
										long BgL_modz00_2838;

										BgL_modz00_2838 =
											(BgL_offsetz00_2837 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 415 */
											long BgL_restz00_2840;

											BgL_restz00_2840 =
												(BgL_offsetz00_2837 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 415 */

												{	/* Llib/thread.scm 415 */
													obj_t BgL_bucketz00_2842;

													BgL_bucketz00_2842 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2833), BgL_modz00_2838);
													BgL_res2018z00_2861 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2842), BgL_restz00_2840);
					}}}}}}}}
					BgL_method1209z00_1656 = BgL_res2018z00_2861;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1209z00_1656, ((obj_t) BgL_thz00_35));
			}
		}

	}



/* &thread-specific */
	obj_t BGl_z62threadzd2specificzb0zz__threadz00(obj_t BgL_envz00_3775,
		obj_t BgL_thz00_3776)
	{
		{	/* Llib/thread.scm 415 */
			{	/* Llib/thread.scm 415 */
				BgL_threadz00_bglt BgL_auxz00_6707;

				{	/* Llib/thread.scm 415 */
					bool_t BgL_test2795z00_6708;

					{	/* Llib/thread.scm 415 */
						obj_t BgL_classz00_4629;

						BgL_classz00_4629 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3776))
							{	/* Llib/thread.scm 415 */
								BgL_objectz00_bglt BgL_arg1947z00_4631;
								long BgL_arg1948z00_4632;

								BgL_arg1947z00_4631 = (BgL_objectz00_bglt) (BgL_thz00_3776);
								BgL_arg1948z00_4632 = BGL_CLASS_DEPTH(BgL_classz00_4629);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 415 */
										long BgL_idxz00_4640;

										BgL_idxz00_4640 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4631);
										{	/* Llib/thread.scm 415 */
											obj_t BgL_arg1938z00_4641;

											{	/* Llib/thread.scm 415 */
												long BgL_arg1939z00_4642;

												BgL_arg1939z00_4642 =
													(BgL_idxz00_4640 + BgL_arg1948z00_4632);
												BgL_arg1938z00_4641 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4642);
											}
											BgL_test2795z00_6708 =
												(BgL_arg1938z00_4641 == BgL_classz00_4629);
									}}
								else
									{	/* Llib/thread.scm 415 */
										bool_t BgL_res2061z00_4647;

										{	/* Llib/thread.scm 415 */
											obj_t BgL_oclassz00_4651;

											{	/* Llib/thread.scm 415 */
												obj_t BgL_arg1954z00_4653;
												long BgL_arg1955z00_4654;

												BgL_arg1954z00_4653 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 415 */
													long BgL_arg1956z00_4655;

													BgL_arg1956z00_4655 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4631);
													BgL_arg1955z00_4654 =
														(BgL_arg1956z00_4655 - OBJECT_TYPE);
												}
												BgL_oclassz00_4651 =
													VECTOR_REF(BgL_arg1954z00_4653, BgL_arg1955z00_4654);
											}
											{	/* Llib/thread.scm 415 */
												bool_t BgL__ortest_1149z00_4661;

												BgL__ortest_1149z00_4661 =
													(BgL_classz00_4629 == BgL_oclassz00_4651);
												if (BgL__ortest_1149z00_4661)
													{	/* Llib/thread.scm 415 */
														BgL_res2061z00_4647 = BgL__ortest_1149z00_4661;
													}
												else
													{	/* Llib/thread.scm 415 */
														long BgL_odepthz00_4662;

														{	/* Llib/thread.scm 415 */
															obj_t BgL_arg1942z00_4663;

															BgL_arg1942z00_4663 = (BgL_oclassz00_4651);
															BgL_odepthz00_4662 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4663);
														}
														if ((BgL_arg1948z00_4632 < BgL_odepthz00_4662))
															{	/* Llib/thread.scm 415 */
																obj_t BgL_arg1940z00_4667;

																{	/* Llib/thread.scm 415 */
																	obj_t BgL_arg1941z00_4668;

																	BgL_arg1941z00_4668 = (BgL_oclassz00_4651);
																	BgL_arg1940z00_4667 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4668,
																		BgL_arg1948z00_4632);
																}
																BgL_res2061z00_4647 =
																	(BgL_arg1940z00_4667 == BgL_classz00_4629);
															}
														else
															{	/* Llib/thread.scm 415 */
																BgL_res2061z00_4647 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2795z00_6708 = BgL_res2061z00_4647;
									}
							}
						else
							{	/* Llib/thread.scm 415 */
								BgL_test2795z00_6708 = ((bool_t) 0);
							}
					}
					if (BgL_test2795z00_6708)
						{	/* Llib/thread.scm 415 */
							BgL_auxz00_6707 = ((BgL_threadz00_bglt) BgL_thz00_3776);
						}
					else
						{
							obj_t BgL_auxz00_6733;

							BgL_auxz00_6733 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(17514L), BGl_string2386z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3776);
							FAILURE(BgL_auxz00_6733, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2specificzd2zz__threadz00(BgL_auxz00_6707);
			}
		}

	}



/* thread-specific-set! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2specificzd2setz12z12zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_36, obj_t BgL_vz00_37)
	{
		{	/* Llib/thread.scm 420 */
			{	/* Llib/thread.scm 420 */
				obj_t BgL_method1211z00_1657;

				{	/* Llib/thread.scm 420 */
					obj_t BgL_res2023z00_2892;

					{	/* Llib/thread.scm 420 */
						long BgL_objzd2classzd2numz00_2863;

						BgL_objzd2classzd2numz00_2863 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_36));
						{	/* Llib/thread.scm 420 */
							obj_t BgL_arg1949z00_2864;

							BgL_arg1949z00_2864 =
								PROCEDURE_REF
								(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 420 */
								int BgL_offsetz00_2867;

								BgL_offsetz00_2867 = (int) (BgL_objzd2classzd2numz00_2863);
								{	/* Llib/thread.scm 420 */
									long BgL_offsetz00_2868;

									BgL_offsetz00_2868 =
										((long) (BgL_offsetz00_2867) - OBJECT_TYPE);
									{	/* Llib/thread.scm 420 */
										long BgL_modz00_2869;

										BgL_modz00_2869 =
											(BgL_offsetz00_2868 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 420 */
											long BgL_restz00_2871;

											BgL_restz00_2871 =
												(BgL_offsetz00_2868 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 420 */

												{	/* Llib/thread.scm 420 */
													obj_t BgL_bucketz00_2873;

													BgL_bucketz00_2873 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2864), BgL_modz00_2869);
													BgL_res2023z00_2892 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2873), BgL_restz00_2871);
					}}}}}}}}
					BgL_method1211z00_1657 = BgL_res2023z00_2892;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1211z00_1657,
					((obj_t) BgL_thz00_36), BgL_vz00_37);
			}
		}

	}



/* &thread-specific-set! */
	obj_t BGl_z62threadzd2specificzd2setz12z70zz__threadz00(obj_t BgL_envz00_3777,
		obj_t BgL_thz00_3778, obj_t BgL_vz00_3779)
	{
		{	/* Llib/thread.scm 420 */
			{	/* Llib/thread.scm 420 */
				BgL_threadz00_bglt BgL_auxz00_6769;

				{	/* Llib/thread.scm 420 */
					bool_t BgL_test2800z00_6770;

					{	/* Llib/thread.scm 420 */
						obj_t BgL_classz00_4669;

						BgL_classz00_4669 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3778))
							{	/* Llib/thread.scm 420 */
								BgL_objectz00_bglt BgL_arg1947z00_4671;
								long BgL_arg1948z00_4672;

								BgL_arg1947z00_4671 = (BgL_objectz00_bglt) (BgL_thz00_3778);
								BgL_arg1948z00_4672 = BGL_CLASS_DEPTH(BgL_classz00_4669);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 420 */
										long BgL_idxz00_4680;

										BgL_idxz00_4680 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4671);
										{	/* Llib/thread.scm 420 */
											obj_t BgL_arg1938z00_4681;

											{	/* Llib/thread.scm 420 */
												long BgL_arg1939z00_4682;

												BgL_arg1939z00_4682 =
													(BgL_idxz00_4680 + BgL_arg1948z00_4672);
												BgL_arg1938z00_4681 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4682);
											}
											BgL_test2800z00_6770 =
												(BgL_arg1938z00_4681 == BgL_classz00_4669);
									}}
								else
									{	/* Llib/thread.scm 420 */
										bool_t BgL_res2061z00_4687;

										{	/* Llib/thread.scm 420 */
											obj_t BgL_oclassz00_4691;

											{	/* Llib/thread.scm 420 */
												obj_t BgL_arg1954z00_4693;
												long BgL_arg1955z00_4694;

												BgL_arg1954z00_4693 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 420 */
													long BgL_arg1956z00_4695;

													BgL_arg1956z00_4695 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4671);
													BgL_arg1955z00_4694 =
														(BgL_arg1956z00_4695 - OBJECT_TYPE);
												}
												BgL_oclassz00_4691 =
													VECTOR_REF(BgL_arg1954z00_4693, BgL_arg1955z00_4694);
											}
											{	/* Llib/thread.scm 420 */
												bool_t BgL__ortest_1149z00_4701;

												BgL__ortest_1149z00_4701 =
													(BgL_classz00_4669 == BgL_oclassz00_4691);
												if (BgL__ortest_1149z00_4701)
													{	/* Llib/thread.scm 420 */
														BgL_res2061z00_4687 = BgL__ortest_1149z00_4701;
													}
												else
													{	/* Llib/thread.scm 420 */
														long BgL_odepthz00_4702;

														{	/* Llib/thread.scm 420 */
															obj_t BgL_arg1942z00_4703;

															BgL_arg1942z00_4703 = (BgL_oclassz00_4691);
															BgL_odepthz00_4702 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4703);
														}
														if ((BgL_arg1948z00_4672 < BgL_odepthz00_4702))
															{	/* Llib/thread.scm 420 */
																obj_t BgL_arg1940z00_4707;

																{	/* Llib/thread.scm 420 */
																	obj_t BgL_arg1941z00_4708;

																	BgL_arg1941z00_4708 = (BgL_oclassz00_4691);
																	BgL_arg1940z00_4707 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4708,
																		BgL_arg1948z00_4672);
																}
																BgL_res2061z00_4687 =
																	(BgL_arg1940z00_4707 == BgL_classz00_4669);
															}
														else
															{	/* Llib/thread.scm 420 */
																BgL_res2061z00_4687 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2800z00_6770 = BgL_res2061z00_4687;
									}
							}
						else
							{	/* Llib/thread.scm 420 */
								BgL_test2800z00_6770 = ((bool_t) 0);
							}
					}
					if (BgL_test2800z00_6770)
						{	/* Llib/thread.scm 420 */
							BgL_auxz00_6769 = ((BgL_threadz00_bglt) BgL_thz00_3778);
						}
					else
						{
							obj_t BgL_auxz00_6795;

							BgL_auxz00_6795 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(17783L), BGl_string2387z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3778);
							FAILURE(BgL_auxz00_6795, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2specificzd2setz12z12zz__threadz00(BgL_auxz00_6769,
					BgL_vz00_3779);
			}
		}

	}



/* thread-cleanup */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2cleanupzd2zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_38)
	{
		{	/* Llib/thread.scm 425 */
			{	/* Llib/thread.scm 425 */
				obj_t BgL_method1213z00_1658;

				{	/* Llib/thread.scm 425 */
					obj_t BgL_res2028z00_2923;

					{	/* Llib/thread.scm 425 */
						long BgL_objzd2classzd2numz00_2894;

						BgL_objzd2classzd2numz00_2894 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_38));
						{	/* Llib/thread.scm 425 */
							obj_t BgL_arg1949z00_2895;

							BgL_arg1949z00_2895 =
								PROCEDURE_REF(BGl_threadzd2cleanupzd2envz00zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 425 */
								int BgL_offsetz00_2898;

								BgL_offsetz00_2898 = (int) (BgL_objzd2classzd2numz00_2894);
								{	/* Llib/thread.scm 425 */
									long BgL_offsetz00_2899;

									BgL_offsetz00_2899 =
										((long) (BgL_offsetz00_2898) - OBJECT_TYPE);
									{	/* Llib/thread.scm 425 */
										long BgL_modz00_2900;

										BgL_modz00_2900 =
											(BgL_offsetz00_2899 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 425 */
											long BgL_restz00_2902;

											BgL_restz00_2902 =
												(BgL_offsetz00_2899 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 425 */

												{	/* Llib/thread.scm 425 */
													obj_t BgL_bucketz00_2904;

													BgL_bucketz00_2904 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2895), BgL_modz00_2900);
													BgL_res2028z00_2923 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2904), BgL_restz00_2902);
					}}}}}}}}
					BgL_method1213z00_1658 = BgL_res2028z00_2923;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1213z00_1658, ((obj_t) BgL_thz00_38));
			}
		}

	}



/* &thread-cleanup */
	obj_t BGl_z62threadzd2cleanupzb0zz__threadz00(obj_t BgL_envz00_3780,
		obj_t BgL_thz00_3781)
	{
		{	/* Llib/thread.scm 425 */
			{	/* Llib/thread.scm 425 */
				BgL_threadz00_bglt BgL_auxz00_6830;

				{	/* Llib/thread.scm 425 */
					bool_t BgL_test2805z00_6831;

					{	/* Llib/thread.scm 425 */
						obj_t BgL_classz00_4709;

						BgL_classz00_4709 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3781))
							{	/* Llib/thread.scm 425 */
								BgL_objectz00_bglt BgL_arg1947z00_4711;
								long BgL_arg1948z00_4712;

								BgL_arg1947z00_4711 = (BgL_objectz00_bglt) (BgL_thz00_3781);
								BgL_arg1948z00_4712 = BGL_CLASS_DEPTH(BgL_classz00_4709);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 425 */
										long BgL_idxz00_4720;

										BgL_idxz00_4720 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4711);
										{	/* Llib/thread.scm 425 */
											obj_t BgL_arg1938z00_4721;

											{	/* Llib/thread.scm 425 */
												long BgL_arg1939z00_4722;

												BgL_arg1939z00_4722 =
													(BgL_idxz00_4720 + BgL_arg1948z00_4712);
												BgL_arg1938z00_4721 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4722);
											}
											BgL_test2805z00_6831 =
												(BgL_arg1938z00_4721 == BgL_classz00_4709);
									}}
								else
									{	/* Llib/thread.scm 425 */
										bool_t BgL_res2061z00_4727;

										{	/* Llib/thread.scm 425 */
											obj_t BgL_oclassz00_4731;

											{	/* Llib/thread.scm 425 */
												obj_t BgL_arg1954z00_4733;
												long BgL_arg1955z00_4734;

												BgL_arg1954z00_4733 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 425 */
													long BgL_arg1956z00_4735;

													BgL_arg1956z00_4735 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4711);
													BgL_arg1955z00_4734 =
														(BgL_arg1956z00_4735 - OBJECT_TYPE);
												}
												BgL_oclassz00_4731 =
													VECTOR_REF(BgL_arg1954z00_4733, BgL_arg1955z00_4734);
											}
											{	/* Llib/thread.scm 425 */
												bool_t BgL__ortest_1149z00_4741;

												BgL__ortest_1149z00_4741 =
													(BgL_classz00_4709 == BgL_oclassz00_4731);
												if (BgL__ortest_1149z00_4741)
													{	/* Llib/thread.scm 425 */
														BgL_res2061z00_4727 = BgL__ortest_1149z00_4741;
													}
												else
													{	/* Llib/thread.scm 425 */
														long BgL_odepthz00_4742;

														{	/* Llib/thread.scm 425 */
															obj_t BgL_arg1942z00_4743;

															BgL_arg1942z00_4743 = (BgL_oclassz00_4731);
															BgL_odepthz00_4742 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4743);
														}
														if ((BgL_arg1948z00_4712 < BgL_odepthz00_4742))
															{	/* Llib/thread.scm 425 */
																obj_t BgL_arg1940z00_4747;

																{	/* Llib/thread.scm 425 */
																	obj_t BgL_arg1941z00_4748;

																	BgL_arg1941z00_4748 = (BgL_oclassz00_4731);
																	BgL_arg1940z00_4747 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4748,
																		BgL_arg1948z00_4712);
																}
																BgL_res2061z00_4727 =
																	(BgL_arg1940z00_4747 == BgL_classz00_4709);
															}
														else
															{	/* Llib/thread.scm 425 */
																BgL_res2061z00_4727 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2805z00_6831 = BgL_res2061z00_4727;
									}
							}
						else
							{	/* Llib/thread.scm 425 */
								BgL_test2805z00_6831 = ((bool_t) 0);
							}
					}
					if (BgL_test2805z00_6831)
						{	/* Llib/thread.scm 425 */
							BgL_auxz00_6830 = ((BgL_threadz00_bglt) BgL_thz00_3781);
						}
					else
						{
							obj_t BgL_auxz00_6856;

							BgL_auxz00_6856 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(18064L), BGl_string2388z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3781);
							FAILURE(BgL_auxz00_6856, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2cleanupzd2zz__threadz00(BgL_auxz00_6830);
			}
		}

	}



/* thread-cleanup-set! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2cleanupzd2setz12z12zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_39, obj_t BgL_vz00_40)
	{
		{	/* Llib/thread.scm 430 */
			{	/* Llib/thread.scm 430 */
				obj_t BgL_method1215z00_1659;

				{	/* Llib/thread.scm 430 */
					obj_t BgL_res2033z00_2954;

					{	/* Llib/thread.scm 430 */
						long BgL_objzd2classzd2numz00_2925;

						BgL_objzd2classzd2numz00_2925 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_39));
						{	/* Llib/thread.scm 430 */
							obj_t BgL_arg1949z00_2926;

							BgL_arg1949z00_2926 =
								PROCEDURE_REF
								(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 430 */
								int BgL_offsetz00_2929;

								BgL_offsetz00_2929 = (int) (BgL_objzd2classzd2numz00_2925);
								{	/* Llib/thread.scm 430 */
									long BgL_offsetz00_2930;

									BgL_offsetz00_2930 =
										((long) (BgL_offsetz00_2929) - OBJECT_TYPE);
									{	/* Llib/thread.scm 430 */
										long BgL_modz00_2931;

										BgL_modz00_2931 =
											(BgL_offsetz00_2930 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 430 */
											long BgL_restz00_2933;

											BgL_restz00_2933 =
												(BgL_offsetz00_2930 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 430 */

												{	/* Llib/thread.scm 430 */
													obj_t BgL_bucketz00_2935;

													BgL_bucketz00_2935 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2926), BgL_modz00_2931);
													BgL_res2033z00_2954 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2935), BgL_restz00_2933);
					}}}}}}}}
					BgL_method1215z00_1659 = BgL_res2033z00_2954;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1215z00_1659,
					((obj_t) BgL_thz00_39), BgL_vz00_40);
			}
		}

	}



/* &thread-cleanup-set! */
	obj_t BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00(obj_t BgL_envz00_3782,
		obj_t BgL_thz00_3783, obj_t BgL_vz00_3784)
	{
		{	/* Llib/thread.scm 430 */
			{	/* Llib/thread.scm 430 */
				BgL_threadz00_bglt BgL_auxz00_6892;

				{	/* Llib/thread.scm 430 */
					bool_t BgL_test2810z00_6893;

					{	/* Llib/thread.scm 430 */
						obj_t BgL_classz00_4749;

						BgL_classz00_4749 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3783))
							{	/* Llib/thread.scm 430 */
								BgL_objectz00_bglt BgL_arg1947z00_4751;
								long BgL_arg1948z00_4752;

								BgL_arg1947z00_4751 = (BgL_objectz00_bglt) (BgL_thz00_3783);
								BgL_arg1948z00_4752 = BGL_CLASS_DEPTH(BgL_classz00_4749);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 430 */
										long BgL_idxz00_4760;

										BgL_idxz00_4760 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4751);
										{	/* Llib/thread.scm 430 */
											obj_t BgL_arg1938z00_4761;

											{	/* Llib/thread.scm 430 */
												long BgL_arg1939z00_4762;

												BgL_arg1939z00_4762 =
													(BgL_idxz00_4760 + BgL_arg1948z00_4752);
												BgL_arg1938z00_4761 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4762);
											}
											BgL_test2810z00_6893 =
												(BgL_arg1938z00_4761 == BgL_classz00_4749);
									}}
								else
									{	/* Llib/thread.scm 430 */
										bool_t BgL_res2061z00_4767;

										{	/* Llib/thread.scm 430 */
											obj_t BgL_oclassz00_4771;

											{	/* Llib/thread.scm 430 */
												obj_t BgL_arg1954z00_4773;
												long BgL_arg1955z00_4774;

												BgL_arg1954z00_4773 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 430 */
													long BgL_arg1956z00_4775;

													BgL_arg1956z00_4775 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4751);
													BgL_arg1955z00_4774 =
														(BgL_arg1956z00_4775 - OBJECT_TYPE);
												}
												BgL_oclassz00_4771 =
													VECTOR_REF(BgL_arg1954z00_4773, BgL_arg1955z00_4774);
											}
											{	/* Llib/thread.scm 430 */
												bool_t BgL__ortest_1149z00_4781;

												BgL__ortest_1149z00_4781 =
													(BgL_classz00_4749 == BgL_oclassz00_4771);
												if (BgL__ortest_1149z00_4781)
													{	/* Llib/thread.scm 430 */
														BgL_res2061z00_4767 = BgL__ortest_1149z00_4781;
													}
												else
													{	/* Llib/thread.scm 430 */
														long BgL_odepthz00_4782;

														{	/* Llib/thread.scm 430 */
															obj_t BgL_arg1942z00_4783;

															BgL_arg1942z00_4783 = (BgL_oclassz00_4771);
															BgL_odepthz00_4782 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4783);
														}
														if ((BgL_arg1948z00_4752 < BgL_odepthz00_4782))
															{	/* Llib/thread.scm 430 */
																obj_t BgL_arg1940z00_4787;

																{	/* Llib/thread.scm 430 */
																	obj_t BgL_arg1941z00_4788;

																	BgL_arg1941z00_4788 = (BgL_oclassz00_4771);
																	BgL_arg1940z00_4787 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4788,
																		BgL_arg1948z00_4752);
																}
																BgL_res2061z00_4767 =
																	(BgL_arg1940z00_4787 == BgL_classz00_4749);
															}
														else
															{	/* Llib/thread.scm 430 */
																BgL_res2061z00_4767 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2810z00_6893 = BgL_res2061z00_4767;
									}
							}
						else
							{	/* Llib/thread.scm 430 */
								BgL_test2810z00_6893 = ((bool_t) 0);
							}
					}
					if (BgL_test2810z00_6893)
						{	/* Llib/thread.scm 430 */
							BgL_auxz00_6892 = ((BgL_threadz00_bglt) BgL_thz00_3783);
						}
					else
						{
							obj_t BgL_auxz00_6918;

							BgL_auxz00_6918 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(18332L), BGl_string2389z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3783);
							FAILURE(BgL_auxz00_6918, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2cleanupzd2setz12z12zz__threadz00(BgL_auxz00_6892,
					BgL_vz00_3784);
			}
		}

	}



/* thread-name */
	BGL_EXPORTED_DEF obj_t BGl_threadzd2namezd2zz__threadz00(BgL_threadz00_bglt
		BgL_thz00_41)
	{
		{	/* Llib/thread.scm 435 */
			{	/* Llib/thread.scm 435 */
				obj_t BgL_method1217z00_1660;

				{	/* Llib/thread.scm 435 */
					obj_t BgL_res2038z00_2985;

					{	/* Llib/thread.scm 435 */
						long BgL_objzd2classzd2numz00_2956;

						BgL_objzd2classzd2numz00_2956 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_41));
						{	/* Llib/thread.scm 435 */
							obj_t BgL_arg1949z00_2957;

							BgL_arg1949z00_2957 =
								PROCEDURE_REF(BGl_threadzd2namezd2envz00zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 435 */
								int BgL_offsetz00_2960;

								BgL_offsetz00_2960 = (int) (BgL_objzd2classzd2numz00_2956);
								{	/* Llib/thread.scm 435 */
									long BgL_offsetz00_2961;

									BgL_offsetz00_2961 =
										((long) (BgL_offsetz00_2960) - OBJECT_TYPE);
									{	/* Llib/thread.scm 435 */
										long BgL_modz00_2962;

										BgL_modz00_2962 =
											(BgL_offsetz00_2961 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 435 */
											long BgL_restz00_2964;

											BgL_restz00_2964 =
												(BgL_offsetz00_2961 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 435 */

												{	/* Llib/thread.scm 435 */
													obj_t BgL_bucketz00_2966;

													BgL_bucketz00_2966 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2957), BgL_modz00_2962);
													BgL_res2038z00_2985 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2966), BgL_restz00_2964);
					}}}}}}}}
					BgL_method1217z00_1660 = BgL_res2038z00_2985;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1217z00_1660, ((obj_t) BgL_thz00_41));
			}
		}

	}



/* &thread-name */
	obj_t BGl_z62threadzd2namezb0zz__threadz00(obj_t BgL_envz00_3785,
		obj_t BgL_thz00_3786)
	{
		{	/* Llib/thread.scm 435 */
			{	/* Llib/thread.scm 435 */
				BgL_threadz00_bglt BgL_auxz00_6953;

				{	/* Llib/thread.scm 435 */
					bool_t BgL_test2815z00_6954;

					{	/* Llib/thread.scm 435 */
						obj_t BgL_classz00_4789;

						BgL_classz00_4789 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3786))
							{	/* Llib/thread.scm 435 */
								BgL_objectz00_bglt BgL_arg1947z00_4791;
								long BgL_arg1948z00_4792;

								BgL_arg1947z00_4791 = (BgL_objectz00_bglt) (BgL_thz00_3786);
								BgL_arg1948z00_4792 = BGL_CLASS_DEPTH(BgL_classz00_4789);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 435 */
										long BgL_idxz00_4800;

										BgL_idxz00_4800 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4791);
										{	/* Llib/thread.scm 435 */
											obj_t BgL_arg1938z00_4801;

											{	/* Llib/thread.scm 435 */
												long BgL_arg1939z00_4802;

												BgL_arg1939z00_4802 =
													(BgL_idxz00_4800 + BgL_arg1948z00_4792);
												BgL_arg1938z00_4801 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4802);
											}
											BgL_test2815z00_6954 =
												(BgL_arg1938z00_4801 == BgL_classz00_4789);
									}}
								else
									{	/* Llib/thread.scm 435 */
										bool_t BgL_res2061z00_4807;

										{	/* Llib/thread.scm 435 */
											obj_t BgL_oclassz00_4811;

											{	/* Llib/thread.scm 435 */
												obj_t BgL_arg1954z00_4813;
												long BgL_arg1955z00_4814;

												BgL_arg1954z00_4813 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 435 */
													long BgL_arg1956z00_4815;

													BgL_arg1956z00_4815 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4791);
													BgL_arg1955z00_4814 =
														(BgL_arg1956z00_4815 - OBJECT_TYPE);
												}
												BgL_oclassz00_4811 =
													VECTOR_REF(BgL_arg1954z00_4813, BgL_arg1955z00_4814);
											}
											{	/* Llib/thread.scm 435 */
												bool_t BgL__ortest_1149z00_4821;

												BgL__ortest_1149z00_4821 =
													(BgL_classz00_4789 == BgL_oclassz00_4811);
												if (BgL__ortest_1149z00_4821)
													{	/* Llib/thread.scm 435 */
														BgL_res2061z00_4807 = BgL__ortest_1149z00_4821;
													}
												else
													{	/* Llib/thread.scm 435 */
														long BgL_odepthz00_4822;

														{	/* Llib/thread.scm 435 */
															obj_t BgL_arg1942z00_4823;

															BgL_arg1942z00_4823 = (BgL_oclassz00_4811);
															BgL_odepthz00_4822 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4823);
														}
														if ((BgL_arg1948z00_4792 < BgL_odepthz00_4822))
															{	/* Llib/thread.scm 435 */
																obj_t BgL_arg1940z00_4827;

																{	/* Llib/thread.scm 435 */
																	obj_t BgL_arg1941z00_4828;

																	BgL_arg1941z00_4828 = (BgL_oclassz00_4811);
																	BgL_arg1940z00_4827 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4828,
																		BgL_arg1948z00_4792);
																}
																BgL_res2061z00_4807 =
																	(BgL_arg1940z00_4827 == BgL_classz00_4789);
															}
														else
															{	/* Llib/thread.scm 435 */
																BgL_res2061z00_4807 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2815z00_6954 = BgL_res2061z00_4807;
									}
							}
						else
							{	/* Llib/thread.scm 435 */
								BgL_test2815z00_6954 = ((bool_t) 0);
							}
					}
					if (BgL_test2815z00_6954)
						{	/* Llib/thread.scm 435 */
							BgL_auxz00_6953 = ((BgL_threadz00_bglt) BgL_thz00_3786);
						}
					else
						{
							obj_t BgL_auxz00_6979;

							BgL_auxz00_6979 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(18612L), BGl_string2390z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3786);
							FAILURE(BgL_auxz00_6979, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2namezd2zz__threadz00(BgL_auxz00_6953);
			}
		}

	}



/* thread-name-set! */
	BGL_EXPORTED_DEF obj_t
		BGl_threadzd2namezd2setz12z12zz__threadz00(BgL_threadz00_bglt BgL_thz00_42,
		obj_t BgL_vz00_43)
	{
		{	/* Llib/thread.scm 440 */
			{	/* Llib/thread.scm 440 */
				obj_t BgL_method1219z00_1661;

				{	/* Llib/thread.scm 440 */
					obj_t BgL_res2043z00_3016;

					{	/* Llib/thread.scm 440 */
						long BgL_objzd2classzd2numz00_2987;

						BgL_objzd2classzd2numz00_2987 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_42));
						{	/* Llib/thread.scm 440 */
							obj_t BgL_arg1949z00_2988;

							BgL_arg1949z00_2988 =
								PROCEDURE_REF(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 440 */
								int BgL_offsetz00_2991;

								BgL_offsetz00_2991 = (int) (BgL_objzd2classzd2numz00_2987);
								{	/* Llib/thread.scm 440 */
									long BgL_offsetz00_2992;

									BgL_offsetz00_2992 =
										((long) (BgL_offsetz00_2991) - OBJECT_TYPE);
									{	/* Llib/thread.scm 440 */
										long BgL_modz00_2993;

										BgL_modz00_2993 =
											(BgL_offsetz00_2992 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 440 */
											long BgL_restz00_2995;

											BgL_restz00_2995 =
												(BgL_offsetz00_2992 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 440 */

												{	/* Llib/thread.scm 440 */
													obj_t BgL_bucketz00_2997;

													BgL_bucketz00_2997 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_2988), BgL_modz00_2993);
													BgL_res2043z00_3016 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2997), BgL_restz00_2995);
					}}}}}}}}
					BgL_method1219z00_1661 = BgL_res2043z00_3016;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1219z00_1661,
					((obj_t) BgL_thz00_42), BgL_vz00_43);
			}
		}

	}



/* &thread-name-set! */
	obj_t BGl_z62threadzd2namezd2setz12z70zz__threadz00(obj_t BgL_envz00_3787,
		obj_t BgL_thz00_3788, obj_t BgL_vz00_3789)
	{
		{	/* Llib/thread.scm 440 */
			{	/* Llib/thread.scm 440 */
				obj_t BgL_auxz00_7045;
				BgL_threadz00_bglt BgL_auxz00_7015;

				if (STRINGP(BgL_vz00_3789))
					{	/* Llib/thread.scm 440 */
						BgL_auxz00_7045 = BgL_vz00_3789;
					}
				else
					{
						obj_t BgL_auxz00_7048;

						BgL_auxz00_7048 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
							BINT(18877L), BGl_string2391z00zz__threadz00,
							BGl_string2218z00zz__threadz00, BgL_vz00_3789);
						FAILURE(BgL_auxz00_7048, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 440 */
					bool_t BgL_test2820z00_7016;

					{	/* Llib/thread.scm 440 */
						obj_t BgL_classz00_4829;

						BgL_classz00_4829 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3788))
							{	/* Llib/thread.scm 440 */
								BgL_objectz00_bglt BgL_arg1947z00_4831;
								long BgL_arg1948z00_4832;

								BgL_arg1947z00_4831 = (BgL_objectz00_bglt) (BgL_thz00_3788);
								BgL_arg1948z00_4832 = BGL_CLASS_DEPTH(BgL_classz00_4829);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 440 */
										long BgL_idxz00_4840;

										BgL_idxz00_4840 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4831);
										{	/* Llib/thread.scm 440 */
											obj_t BgL_arg1938z00_4841;

											{	/* Llib/thread.scm 440 */
												long BgL_arg1939z00_4842;

												BgL_arg1939z00_4842 =
													(BgL_idxz00_4840 + BgL_arg1948z00_4832);
												BgL_arg1938z00_4841 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4842);
											}
											BgL_test2820z00_7016 =
												(BgL_arg1938z00_4841 == BgL_classz00_4829);
									}}
								else
									{	/* Llib/thread.scm 440 */
										bool_t BgL_res2061z00_4847;

										{	/* Llib/thread.scm 440 */
											obj_t BgL_oclassz00_4851;

											{	/* Llib/thread.scm 440 */
												obj_t BgL_arg1954z00_4853;
												long BgL_arg1955z00_4854;

												BgL_arg1954z00_4853 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 440 */
													long BgL_arg1956z00_4855;

													BgL_arg1956z00_4855 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4831);
													BgL_arg1955z00_4854 =
														(BgL_arg1956z00_4855 - OBJECT_TYPE);
												}
												BgL_oclassz00_4851 =
													VECTOR_REF(BgL_arg1954z00_4853, BgL_arg1955z00_4854);
											}
											{	/* Llib/thread.scm 440 */
												bool_t BgL__ortest_1149z00_4861;

												BgL__ortest_1149z00_4861 =
													(BgL_classz00_4829 == BgL_oclassz00_4851);
												if (BgL__ortest_1149z00_4861)
													{	/* Llib/thread.scm 440 */
														BgL_res2061z00_4847 = BgL__ortest_1149z00_4861;
													}
												else
													{	/* Llib/thread.scm 440 */
														long BgL_odepthz00_4862;

														{	/* Llib/thread.scm 440 */
															obj_t BgL_arg1942z00_4863;

															BgL_arg1942z00_4863 = (BgL_oclassz00_4851);
															BgL_odepthz00_4862 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4863);
														}
														if ((BgL_arg1948z00_4832 < BgL_odepthz00_4862))
															{	/* Llib/thread.scm 440 */
																obj_t BgL_arg1940z00_4867;

																{	/* Llib/thread.scm 440 */
																	obj_t BgL_arg1941z00_4868;

																	BgL_arg1941z00_4868 = (BgL_oclassz00_4851);
																	BgL_arg1940z00_4867 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4868,
																		BgL_arg1948z00_4832);
																}
																BgL_res2061z00_4847 =
																	(BgL_arg1940z00_4867 == BgL_classz00_4829);
															}
														else
															{	/* Llib/thread.scm 440 */
																BgL_res2061z00_4847 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2820z00_7016 = BgL_res2061z00_4847;
									}
							}
						else
							{	/* Llib/thread.scm 440 */
								BgL_test2820z00_7016 = ((bool_t) 0);
							}
					}
					if (BgL_test2820z00_7016)
						{	/* Llib/thread.scm 440 */
							BgL_auxz00_7015 = ((BgL_threadz00_bglt) BgL_thz00_3788);
						}
					else
						{
							obj_t BgL_auxz00_7041;

							BgL_auxz00_7041 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(18877L), BGl_string2391z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_thz00_3788);
							FAILURE(BgL_auxz00_7041, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2namezd2setz12z12zz__threadz00(BgL_auxz00_7015,
					BgL_auxz00_7045);
			}
		}

	}



/* %user-current-thread */
	BGL_EXPORTED_DEF obj_t
		BGl_z52userzd2currentzd2threadz52zz__threadz00(BgL_threadz00_bglt
		BgL_oz00_48)
	{
		{	/* Llib/thread.scm 451 */
			{	/* Llib/thread.scm 451 */
				obj_t BgL_method1227z00_1662;

				{	/* Llib/thread.scm 451 */
					obj_t BgL_res2048z00_3047;

					{	/* Llib/thread.scm 451 */
						long BgL_objzd2classzd2numz00_3018;

						BgL_objzd2classzd2numz00_3018 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_48));
						{	/* Llib/thread.scm 451 */
							obj_t BgL_arg1949z00_3019;

							BgL_arg1949z00_3019 =
								PROCEDURE_REF
								(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 451 */
								int BgL_offsetz00_3022;

								BgL_offsetz00_3022 = (int) (BgL_objzd2classzd2numz00_3018);
								{	/* Llib/thread.scm 451 */
									long BgL_offsetz00_3023;

									BgL_offsetz00_3023 =
										((long) (BgL_offsetz00_3022) - OBJECT_TYPE);
									{	/* Llib/thread.scm 451 */
										long BgL_modz00_3024;

										BgL_modz00_3024 =
											(BgL_offsetz00_3023 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 451 */
											long BgL_restz00_3026;

											BgL_restz00_3026 =
												(BgL_offsetz00_3023 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 451 */

												{	/* Llib/thread.scm 451 */
													obj_t BgL_bucketz00_3028;

													BgL_bucketz00_3028 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_3019), BgL_modz00_3024);
													BgL_res2048z00_3047 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_3028), BgL_restz00_3026);
					}}}}}}}}
					BgL_method1227z00_1662 = BgL_res2048z00_3047;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1227z00_1662, ((obj_t) BgL_oz00_48));
			}
		}

	}



/* &%user-current-thread */
	obj_t BGl_z62z52userzd2currentzd2threadz30zz__threadz00(obj_t BgL_envz00_3790,
		obj_t BgL_oz00_3791)
	{
		{	/* Llib/thread.scm 451 */
			{	/* Llib/thread.scm 451 */
				BgL_threadz00_bglt BgL_auxz00_7083;

				{	/* Llib/thread.scm 451 */
					bool_t BgL_test2826z00_7084;

					{	/* Llib/thread.scm 451 */
						obj_t BgL_classz00_4869;

						BgL_classz00_4869 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3791))
							{	/* Llib/thread.scm 451 */
								BgL_objectz00_bglt BgL_arg1947z00_4871;
								long BgL_arg1948z00_4872;

								BgL_arg1947z00_4871 = (BgL_objectz00_bglt) (BgL_oz00_3791);
								BgL_arg1948z00_4872 = BGL_CLASS_DEPTH(BgL_classz00_4869);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 451 */
										long BgL_idxz00_4880;

										BgL_idxz00_4880 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4871);
										{	/* Llib/thread.scm 451 */
											obj_t BgL_arg1938z00_4881;

											{	/* Llib/thread.scm 451 */
												long BgL_arg1939z00_4882;

												BgL_arg1939z00_4882 =
													(BgL_idxz00_4880 + BgL_arg1948z00_4872);
												BgL_arg1938z00_4881 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4882);
											}
											BgL_test2826z00_7084 =
												(BgL_arg1938z00_4881 == BgL_classz00_4869);
									}}
								else
									{	/* Llib/thread.scm 451 */
										bool_t BgL_res2061z00_4887;

										{	/* Llib/thread.scm 451 */
											obj_t BgL_oclassz00_4891;

											{	/* Llib/thread.scm 451 */
												obj_t BgL_arg1954z00_4893;
												long BgL_arg1955z00_4894;

												BgL_arg1954z00_4893 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 451 */
													long BgL_arg1956z00_4895;

													BgL_arg1956z00_4895 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4871);
													BgL_arg1955z00_4894 =
														(BgL_arg1956z00_4895 - OBJECT_TYPE);
												}
												BgL_oclassz00_4891 =
													VECTOR_REF(BgL_arg1954z00_4893, BgL_arg1955z00_4894);
											}
											{	/* Llib/thread.scm 451 */
												bool_t BgL__ortest_1149z00_4901;

												BgL__ortest_1149z00_4901 =
													(BgL_classz00_4869 == BgL_oclassz00_4891);
												if (BgL__ortest_1149z00_4901)
													{	/* Llib/thread.scm 451 */
														BgL_res2061z00_4887 = BgL__ortest_1149z00_4901;
													}
												else
													{	/* Llib/thread.scm 451 */
														long BgL_odepthz00_4902;

														{	/* Llib/thread.scm 451 */
															obj_t BgL_arg1942z00_4903;

															BgL_arg1942z00_4903 = (BgL_oclassz00_4891);
															BgL_odepthz00_4902 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4903);
														}
														if ((BgL_arg1948z00_4872 < BgL_odepthz00_4902))
															{	/* Llib/thread.scm 451 */
																obj_t BgL_arg1940z00_4907;

																{	/* Llib/thread.scm 451 */
																	obj_t BgL_arg1941z00_4908;

																	BgL_arg1941z00_4908 = (BgL_oclassz00_4891);
																	BgL_arg1940z00_4907 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4908,
																		BgL_arg1948z00_4872);
																}
																BgL_res2061z00_4887 =
																	(BgL_arg1940z00_4907 == BgL_classz00_4869);
															}
														else
															{	/* Llib/thread.scm 451 */
																BgL_res2061z00_4887 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2826z00_7084 = BgL_res2061z00_4887;
									}
							}
						else
							{	/* Llib/thread.scm 451 */
								BgL_test2826z00_7084 = ((bool_t) 0);
							}
					}
					if (BgL_test2826z00_7084)
						{	/* Llib/thread.scm 451 */
							BgL_auxz00_7083 = ((BgL_threadz00_bglt) BgL_oz00_3791);
						}
					else
						{
							obj_t BgL_auxz00_7109;

							BgL_auxz00_7109 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(19506L), BGl_string2392z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_oz00_3791);
							FAILURE(BgL_auxz00_7109, BFALSE, BFALSE);
						}
				}
				return BGl_z52userzd2currentzd2threadz52zz__threadz00(BgL_auxz00_7083);
			}
		}

	}



/* %user-thread-sleep! */
	BGL_EXPORTED_DEF obj_t
		BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(BgL_threadz00_bglt
		BgL_oz00_49, obj_t BgL_dz00_50)
	{
		{	/* Llib/thread.scm 473 */
			{	/* Llib/thread.scm 473 */
				obj_t BgL_method1230z00_1663;

				{	/* Llib/thread.scm 473 */
					obj_t BgL_res2053z00_3078;

					{	/* Llib/thread.scm 473 */
						long BgL_objzd2classzd2numz00_3049;

						BgL_objzd2classzd2numz00_3049 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_49));
						{	/* Llib/thread.scm 473 */
							obj_t BgL_arg1949z00_3050;

							BgL_arg1949z00_3050 =
								PROCEDURE_REF
								(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 473 */
								int BgL_offsetz00_3053;

								BgL_offsetz00_3053 = (int) (BgL_objzd2classzd2numz00_3049);
								{	/* Llib/thread.scm 473 */
									long BgL_offsetz00_3054;

									BgL_offsetz00_3054 =
										((long) (BgL_offsetz00_3053) - OBJECT_TYPE);
									{	/* Llib/thread.scm 473 */
										long BgL_modz00_3055;

										BgL_modz00_3055 =
											(BgL_offsetz00_3054 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 473 */
											long BgL_restz00_3057;

											BgL_restz00_3057 =
												(BgL_offsetz00_3054 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 473 */

												{	/* Llib/thread.scm 473 */
													obj_t BgL_bucketz00_3059;

													BgL_bucketz00_3059 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_3050), BgL_modz00_3055);
													BgL_res2053z00_3078 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_3059), BgL_restz00_3057);
					}}}}}}}}
					BgL_method1230z00_1663 = BgL_res2053z00_3078;
				}
				return
					BGL_PROCEDURE_CALL2(BgL_method1230z00_1663,
					((obj_t) BgL_oz00_49), BgL_dz00_50);
			}
		}

	}



/* &%user-thread-sleep! */
	obj_t BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00(obj_t
		BgL_envz00_3792, obj_t BgL_oz00_3793, obj_t BgL_dz00_3794)
	{
		{	/* Llib/thread.scm 473 */
			{	/* Llib/thread.scm 473 */
				BgL_threadz00_bglt BgL_auxz00_7145;

				{	/* Llib/thread.scm 473 */
					bool_t BgL_test2831z00_7146;

					{	/* Llib/thread.scm 473 */
						obj_t BgL_classz00_4909;

						BgL_classz00_4909 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3793))
							{	/* Llib/thread.scm 473 */
								BgL_objectz00_bglt BgL_arg1947z00_4911;
								long BgL_arg1948z00_4912;

								BgL_arg1947z00_4911 = (BgL_objectz00_bglt) (BgL_oz00_3793);
								BgL_arg1948z00_4912 = BGL_CLASS_DEPTH(BgL_classz00_4909);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 473 */
										long BgL_idxz00_4920;

										BgL_idxz00_4920 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4911);
										{	/* Llib/thread.scm 473 */
											obj_t BgL_arg1938z00_4921;

											{	/* Llib/thread.scm 473 */
												long BgL_arg1939z00_4922;

												BgL_arg1939z00_4922 =
													(BgL_idxz00_4920 + BgL_arg1948z00_4912);
												BgL_arg1938z00_4921 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4922);
											}
											BgL_test2831z00_7146 =
												(BgL_arg1938z00_4921 == BgL_classz00_4909);
									}}
								else
									{	/* Llib/thread.scm 473 */
										bool_t BgL_res2061z00_4927;

										{	/* Llib/thread.scm 473 */
											obj_t BgL_oclassz00_4931;

											{	/* Llib/thread.scm 473 */
												obj_t BgL_arg1954z00_4933;
												long BgL_arg1955z00_4934;

												BgL_arg1954z00_4933 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 473 */
													long BgL_arg1956z00_4935;

													BgL_arg1956z00_4935 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4911);
													BgL_arg1955z00_4934 =
														(BgL_arg1956z00_4935 - OBJECT_TYPE);
												}
												BgL_oclassz00_4931 =
													VECTOR_REF(BgL_arg1954z00_4933, BgL_arg1955z00_4934);
											}
											{	/* Llib/thread.scm 473 */
												bool_t BgL__ortest_1149z00_4941;

												BgL__ortest_1149z00_4941 =
													(BgL_classz00_4909 == BgL_oclassz00_4931);
												if (BgL__ortest_1149z00_4941)
													{	/* Llib/thread.scm 473 */
														BgL_res2061z00_4927 = BgL__ortest_1149z00_4941;
													}
												else
													{	/* Llib/thread.scm 473 */
														long BgL_odepthz00_4942;

														{	/* Llib/thread.scm 473 */
															obj_t BgL_arg1942z00_4943;

															BgL_arg1942z00_4943 = (BgL_oclassz00_4931);
															BgL_odepthz00_4942 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4943);
														}
														if ((BgL_arg1948z00_4912 < BgL_odepthz00_4942))
															{	/* Llib/thread.scm 473 */
																obj_t BgL_arg1940z00_4947;

																{	/* Llib/thread.scm 473 */
																	obj_t BgL_arg1941z00_4948;

																	BgL_arg1941z00_4948 = (BgL_oclassz00_4931);
																	BgL_arg1940z00_4947 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4948,
																		BgL_arg1948z00_4912);
																}
																BgL_res2061z00_4927 =
																	(BgL_arg1940z00_4947 == BgL_classz00_4909);
															}
														else
															{	/* Llib/thread.scm 473 */
																BgL_res2061z00_4927 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2831z00_7146 = BgL_res2061z00_4927;
									}
							}
						else
							{	/* Llib/thread.scm 473 */
								BgL_test2831z00_7146 = ((bool_t) 0);
							}
					}
					if (BgL_test2831z00_7146)
						{	/* Llib/thread.scm 473 */
							BgL_auxz00_7145 = ((BgL_threadz00_bglt) BgL_oz00_3793);
						}
					else
						{
							obj_t BgL_auxz00_7171;

							BgL_auxz00_7171 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(20480L), BGl_string2393z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_oz00_3793);
							FAILURE(BgL_auxz00_7171, BFALSE, BFALSE);
						}
				}
				return
					BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(BgL_auxz00_7145,
					BgL_dz00_3794);
			}
		}

	}



/* %user-thread-yield! */
	BGL_EXPORTED_DEF obj_t
		BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(BgL_threadz00_bglt
		BgL_oz00_52)
	{
		{	/* Llib/thread.scm 500 */
			{	/* Llib/thread.scm 500 */
				obj_t BgL_method1232z00_1664;

				{	/* Llib/thread.scm 500 */
					obj_t BgL_res2058z00_3109;

					{	/* Llib/thread.scm 500 */
						long BgL_objzd2classzd2numz00_3080;

						BgL_objzd2classzd2numz00_3080 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_52));
						{	/* Llib/thread.scm 500 */
							obj_t BgL_arg1949z00_3081;

							BgL_arg1949z00_3081 =
								PROCEDURE_REF
								(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 500 */
								int BgL_offsetz00_3084;

								BgL_offsetz00_3084 = (int) (BgL_objzd2classzd2numz00_3080);
								{	/* Llib/thread.scm 500 */
									long BgL_offsetz00_3085;

									BgL_offsetz00_3085 =
										((long) (BgL_offsetz00_3084) - OBJECT_TYPE);
									{	/* Llib/thread.scm 500 */
										long BgL_modz00_3086;

										BgL_modz00_3086 =
											(BgL_offsetz00_3085 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 500 */
											long BgL_restz00_3088;

											BgL_restz00_3088 =
												(BgL_offsetz00_3085 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 500 */

												{	/* Llib/thread.scm 500 */
													obj_t BgL_bucketz00_3090;

													BgL_bucketz00_3090 =
														VECTOR_REF(
														((obj_t) BgL_arg1949z00_3081), BgL_modz00_3086);
													BgL_res2058z00_3109 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_3090), BgL_restz00_3088);
					}}}}}}}}
					BgL_method1232z00_1664 = BgL_res2058z00_3109;
				}
				return
					BGL_PROCEDURE_CALL1(BgL_method1232z00_1664, ((obj_t) BgL_oz00_52));
			}
		}

	}



/* &%user-thread-yield! */
	obj_t BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00(obj_t
		BgL_envz00_3795, obj_t BgL_oz00_3796)
	{
		{	/* Llib/thread.scm 500 */
			{	/* Llib/thread.scm 500 */
				BgL_threadz00_bglt BgL_auxz00_7206;

				{	/* Llib/thread.scm 500 */
					bool_t BgL_test2836z00_7207;

					{	/* Llib/thread.scm 500 */
						obj_t BgL_classz00_4949;

						BgL_classz00_4949 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3796))
							{	/* Llib/thread.scm 500 */
								BgL_objectz00_bglt BgL_arg1947z00_4951;
								long BgL_arg1948z00_4952;

								BgL_arg1947z00_4951 = (BgL_objectz00_bglt) (BgL_oz00_3796);
								BgL_arg1948z00_4952 = BGL_CLASS_DEPTH(BgL_classz00_4949);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 500 */
										long BgL_idxz00_4960;

										BgL_idxz00_4960 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1947z00_4951);
										{	/* Llib/thread.scm 500 */
											obj_t BgL_arg1938z00_4961;

											{	/* Llib/thread.scm 500 */
												long BgL_arg1939z00_4962;

												BgL_arg1939z00_4962 =
													(BgL_idxz00_4960 + BgL_arg1948z00_4952);
												BgL_arg1938z00_4961 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1939z00_4962);
											}
											BgL_test2836z00_7207 =
												(BgL_arg1938z00_4961 == BgL_classz00_4949);
									}}
								else
									{	/* Llib/thread.scm 500 */
										bool_t BgL_res2061z00_4967;

										{	/* Llib/thread.scm 500 */
											obj_t BgL_oclassz00_4971;

											{	/* Llib/thread.scm 500 */
												obj_t BgL_arg1954z00_4973;
												long BgL_arg1955z00_4974;

												BgL_arg1954z00_4973 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 500 */
													long BgL_arg1956z00_4975;

													BgL_arg1956z00_4975 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1947z00_4951);
													BgL_arg1955z00_4974 =
														(BgL_arg1956z00_4975 - OBJECT_TYPE);
												}
												BgL_oclassz00_4971 =
													VECTOR_REF(BgL_arg1954z00_4973, BgL_arg1955z00_4974);
											}
											{	/* Llib/thread.scm 500 */
												bool_t BgL__ortest_1149z00_4981;

												BgL__ortest_1149z00_4981 =
													(BgL_classz00_4949 == BgL_oclassz00_4971);
												if (BgL__ortest_1149z00_4981)
													{	/* Llib/thread.scm 500 */
														BgL_res2061z00_4967 = BgL__ortest_1149z00_4981;
													}
												else
													{	/* Llib/thread.scm 500 */
														long BgL_odepthz00_4982;

														{	/* Llib/thread.scm 500 */
															obj_t BgL_arg1942z00_4983;

															BgL_arg1942z00_4983 = (BgL_oclassz00_4971);
															BgL_odepthz00_4982 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_4983);
														}
														if ((BgL_arg1948z00_4952 < BgL_odepthz00_4982))
															{	/* Llib/thread.scm 500 */
																obj_t BgL_arg1940z00_4987;

																{	/* Llib/thread.scm 500 */
																	obj_t BgL_arg1941z00_4988;

																	BgL_arg1941z00_4988 = (BgL_oclassz00_4971);
																	BgL_arg1940z00_4987 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_4988,
																		BgL_arg1948z00_4952);
																}
																BgL_res2061z00_4967 =
																	(BgL_arg1940z00_4987 == BgL_classz00_4949);
															}
														else
															{	/* Llib/thread.scm 500 */
																BgL_res2061z00_4967 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2836z00_7207 = BgL_res2061z00_4967;
									}
							}
						else
							{	/* Llib/thread.scm 500 */
								BgL_test2836z00_7207 = ((bool_t) 0);
							}
					}
					if (BgL_test2836z00_7207)
						{	/* Llib/thread.scm 500 */
							BgL_auxz00_7206 = ((BgL_threadz00_bglt) BgL_oz00_3796);
						}
					else
						{
							obj_t BgL_auxz00_7232;

							BgL_auxz00_7232 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2213z00zz__threadz00,
								BINT(21576L), BGl_string2394z00zz__threadz00,
								BGl_string2222z00zz__threadz00, BgL_oz00_3796);
							FAILURE(BgL_auxz00_7232, BFALSE, BFALSE);
						}
				}
				return BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(BgL_auxz00_7206);
			}
		}

	}



/* method-init */
	obj_t BGl_methodzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
				BGl_nothreadzd2backendzd2zz__threadz00, BGl_proc2395z00zz__threadz00,
				BGl_string2396z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
				BGl_nothreadzd2backendzd2zz__threadz00, BGl_proc2397z00zz__threadz00,
				BGl_string2398z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2displayzd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2399z00zz__threadz00, BGl_string2400z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2writezd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2401z00zz__threadz00, BGl_string2402z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2printzd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2403z00zz__threadz00, BGl_string2404z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2startz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2405z00zz__threadz00,
				BGl_string2406z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2407z00zz__threadz00,
				BGl_string2408z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2joinz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2409z00zz__threadz00,
				BGl_string2410z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2411z00zz__threadz00,
				BGl_string2412z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2killz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2413z00zz__threadz00,
				BGl_string2414z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2specificzd2envz00zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2415z00zz__threadz00,
				BGl_string2416z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2417z00zz__threadz00,
				BGl_string2418z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2cleanupzd2envz00zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2419z00zz__threadz00,
				BGl_string2420z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2421z00zz__threadz00,
				BGl_string2422z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2namezd2envz00zz__threadz00, BGl_nothreadz00zz__threadz00,
				BGl_proc2423z00zz__threadz00, BGl_string2424z00zz__threadz00);
			return
				BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2425z00zz__threadz00,
				BGl_string2426z00zz__threadz00);
		}

	}



/* &thread-name-set!-not1254 */
	obj_t BGl_z62threadzd2namezd2setz12zd2not1254za2zz__threadz00(obj_t
		BgL_envz00_3816, obj_t BgL_thz00_3817, obj_t BgL_vz00_3818)
	{
		{	/* Llib/thread.scm 608 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3817)))->BgL_z52namez52) =
				((obj_t) BgL_vz00_3818), BUNSPEC);
		}

	}



/* &thread-name-nothread1252 */
	obj_t BGl_z62threadzd2namezd2nothread1252z62zz__threadz00(obj_t
		BgL_envz00_3819, obj_t BgL_thz00_3820)
	{
		{	/* Llib/thread.scm 602 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3820)))->BgL_z52namez52);
		}

	}



/* &thread-cleanup-set!-1250 */
	obj_t BGl_z62threadzd2cleanupzd2setz12zd21250za2zz__threadz00(obj_t
		BgL_envz00_3821, obj_t BgL_thz00_3822, obj_t BgL_vz00_3823)
	{
		{	/* Llib/thread.scm 596 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3822)))->BgL_z52cleanupz52) =
				((obj_t) BgL_vz00_3823), BUNSPEC);
		}

	}



/* &thread-cleanup-nothr1248 */
	obj_t BGl_z62threadzd2cleanupzd2nothr1248z62zz__threadz00(obj_t
		BgL_envz00_3824, obj_t BgL_thz00_3825)
	{
		{	/* Llib/thread.scm 590 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3825)))->BgL_z52cleanupz52);
		}

	}



/* &thread-specific-set!1246 */
	obj_t BGl_z62threadzd2specificzd2setz121246z70zz__threadz00(obj_t
		BgL_envz00_3826, obj_t BgL_thz00_3827, obj_t BgL_vz00_3828)
	{
		{	/* Llib/thread.scm 584 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3827)))->BgL_z52specificz52) =
				((obj_t) BgL_vz00_3828), BUNSPEC);
		}

	}



/* &thread-specific-noth1244 */
	obj_t BGl_z62threadzd2specificzd2noth1244z62zz__threadz00(obj_t
		BgL_envz00_3829, obj_t BgL_thz00_3830)
	{
		{	/* Llib/thread.scm 578 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3830)))->BgL_z52specificz52);
		}

	}



/* &thread-kill!-nothrea1242 */
	obj_t BGl_z62threadzd2killz12zd2nothrea1242z70zz__threadz00(obj_t
		BgL_envz00_3831, obj_t BgL_thz00_3832, obj_t BgL_nz00_3833)
	{
		{	/* Llib/thread.scm 572 */
			return BUNSPEC;
		}

	}



/* &thread-terminate!-no1240 */
	obj_t BGl_z62threadzd2terminatez12zd2no1240z70zz__threadz00(obj_t
		BgL_envz00_3834, obj_t BgL_thz00_3835)
	{
		{	/* Llib/thread.scm 564 */
			{	/* Llib/thread.scm 566 */
				bool_t BgL_test2841z00_7265;

				{	/* Llib/thread.scm 566 */
					obj_t BgL_tmpz00_7266;

					BgL_tmpz00_7266 =
						(((BgL_nothreadz00_bglt) COBJECT(
								((BgL_nothreadz00_bglt) BgL_thz00_3835)))->BgL_z52cleanupz52);
					BgL_test2841z00_7265 = PROCEDUREP(BgL_tmpz00_7266);
				}
				if (BgL_test2841z00_7265)
					{	/* Llib/thread.scm 566 */
						obj_t BgL_fun1586z00_4998;

						BgL_fun1586z00_4998 =
							(((BgL_nothreadz00_bglt) COBJECT(
									((BgL_nothreadz00_bglt) BgL_thz00_3835)))->BgL_z52cleanupz52);
						BGL_PROCEDURE_CALL0(BgL_fun1586z00_4998);
					}
				else
					{	/* Llib/thread.scm 566 */
						BFALSE;
					}
			}
			{	/* Llib/thread.scm 567 */
				obj_t BgL_list1588z00_4999;

				BgL_list1588z00_4999 = MAKE_YOUNG_PAIR(BINT(0L), BNIL);
				return BGl_exitz00zz__errorz00(BgL_list1588z00_4999);
			}
		}

	}



/* &thread-join!-nothrea1238 */
	obj_t BGl_z62threadzd2joinz12zd2nothrea1238z70zz__threadz00(obj_t
		BgL_envz00_3836, obj_t BgL_thz00_3837, obj_t BgL_timeoutz00_3838)
	{
		{	/* Llib/thread.scm 555 */
			{	/* Llib/thread.scm 557 */
				bool_t BgL_test2842z00_7278;

				{	/* Llib/thread.scm 557 */
					obj_t BgL_arg1581z00_5001;

					BgL_arg1581z00_5001 =
						(((BgL_nothreadz00_bglt) COBJECT(
								((BgL_nothreadz00_bglt) BgL_thz00_3837)))->
						BgL_endzd2exceptionzd2);
					{	/* Llib/thread.scm 557 */
						obj_t BgL_classz00_5002;

						BgL_classz00_5002 = BGl_z62exceptionz62zz__objectz00;
						if (BGL_OBJECTP(BgL_arg1581z00_5001))
							{	/* Llib/thread.scm 557 */
								BgL_objectz00_bglt BgL_arg1945z00_5003;

								BgL_arg1945z00_5003 =
									(BgL_objectz00_bglt) (BgL_arg1581z00_5001);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 557 */
										long BgL_idxz00_5004;

										BgL_idxz00_5004 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1945z00_5003);
										BgL_test2842z00_7278 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_5004 + 2L)) == BgL_classz00_5002);
									}
								else
									{	/* Llib/thread.scm 557 */
										bool_t BgL_res2059z00_5007;

										{	/* Llib/thread.scm 557 */
											obj_t BgL_oclassz00_5008;

											{	/* Llib/thread.scm 557 */
												obj_t BgL_arg1954z00_5009;
												long BgL_arg1955z00_5010;

												BgL_arg1954z00_5009 =
													(BGl_za2classesza2z00zz__objectz00);
												{	/* Llib/thread.scm 557 */
													long BgL_arg1956z00_5011;

													BgL_arg1956z00_5011 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1945z00_5003);
													BgL_arg1955z00_5010 =
														(BgL_arg1956z00_5011 - OBJECT_TYPE);
												}
												BgL_oclassz00_5008 =
													VECTOR_REF(BgL_arg1954z00_5009, BgL_arg1955z00_5010);
											}
											{	/* Llib/thread.scm 557 */
												bool_t BgL__ortest_1149z00_5012;

												BgL__ortest_1149z00_5012 =
													(BgL_classz00_5002 == BgL_oclassz00_5008);
												if (BgL__ortest_1149z00_5012)
													{	/* Llib/thread.scm 557 */
														BgL_res2059z00_5007 = BgL__ortest_1149z00_5012;
													}
												else
													{	/* Llib/thread.scm 557 */
														long BgL_odepthz00_5013;

														{	/* Llib/thread.scm 557 */
															obj_t BgL_arg1942z00_5014;

															BgL_arg1942z00_5014 = (BgL_oclassz00_5008);
															BgL_odepthz00_5013 =
																BGL_CLASS_DEPTH(BgL_arg1942z00_5014);
														}
														if ((2L < BgL_odepthz00_5013))
															{	/* Llib/thread.scm 557 */
																obj_t BgL_arg1940z00_5015;

																{	/* Llib/thread.scm 557 */
																	obj_t BgL_arg1941z00_5016;

																	BgL_arg1941z00_5016 = (BgL_oclassz00_5008);
																	BgL_arg1940z00_5015 =
																		BGL_CLASS_ANCESTORS_REF(BgL_arg1941z00_5016,
																		2L);
																}
																BgL_res2059z00_5007 =
																	(BgL_arg1940z00_5015 == BgL_classz00_5002);
															}
														else
															{	/* Llib/thread.scm 557 */
																BgL_res2059z00_5007 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2842z00_7278 = BgL_res2059z00_5007;
									}
							}
						else
							{	/* Llib/thread.scm 557 */
								BgL_test2842z00_7278 = ((bool_t) 0);
							}
					}
				}
				if (BgL_test2842z00_7278)
					{	/* Llib/thread.scm 557 */
						return
							BGl_raisez00zz__errorz00(
							(((BgL_nothreadz00_bglt) COBJECT(
										((BgL_nothreadz00_bglt) BgL_thz00_3837)))->
								BgL_endzd2exceptionzd2));
					}
				else
					{	/* Llib/thread.scm 557 */
						return
							(((BgL_nothreadz00_bglt) COBJECT(
									((BgL_nothreadz00_bglt) BgL_thz00_3837)))->
							BgL_endzd2resultzd2);
					}
			}
		}

	}



/* &thread-start-joinabl1236 */
	obj_t BGl_z62threadzd2startzd2joinabl1236z62zz__threadz00(obj_t
		BgL_envz00_3839, obj_t BgL_thz00_3840)
	{
		{	/* Llib/thread.scm 549 */
			return
				BGl_threadzd2startz12zc0zz__threadz00(
				((BgL_threadz00_bglt) ((BgL_nothreadz00_bglt) BgL_thz00_3840)), BNIL);
		}

	}



/* &thread-start!-nothre1234 */
	obj_t BGl_z62threadzd2startz12zd2nothre1234z70zz__threadz00(obj_t
		BgL_envz00_3841, obj_t BgL_thz00_3842, obj_t BgL_scdz00_3843)
	{
		{	/* Llib/thread.scm 533 */
			return
				BGl_threadzd2startz12zd2nothre1234ze70zf5zz__threadz00(
				((BgL_nothreadz00_bglt) BgL_thz00_3842), BgL_scdz00_3843);
		}

	}



/* <@exit:1569>~0 */
	obj_t BGl_zc3z04exitza31569ze3ze70z60zz__threadz00(BgL_nothreadz00_bglt
		BgL_i1071z00_3878, obj_t BgL_cell1075z00_3877, obj_t BgL_env1080z00_3876)
	{
		{	/* Llib/thread.scm 538 */
			jmp_buf_t jmpbuf;
			void *BgL_an_exit1084z00_1741;

			if (SET_EXIT(BgL_an_exit1084z00_1741))
				{
					return BGL_EXIT_VALUE();
				}
			else
				{
#if (SIGSETJMP_SAVESIGS == 0)
				 // MS: CARE 5 jan 2021: see runtime/Clib/csystem.c
				 // bgl_restore_signal_handlers();
#endif

					BgL_an_exit1084z00_1741 = (void *) jmpbuf;
					PUSH_ENV_EXIT(BgL_env1080z00_3876, BgL_an_exit1084z00_1741, 1L);
					{	/* Llib/thread.scm 538 */
						obj_t BgL_escape1076z00_1742;

						BgL_escape1076z00_1742 =
							BGL_ENV_EXITD_TOP_AS_OBJ(BgL_env1080z00_3876);
						{	/* Llib/thread.scm 538 */
							obj_t BgL_res1087z00_1743;

							{	/* Llib/thread.scm 538 */
								obj_t BgL_ohs1072z00_1744;

								BgL_ohs1072z00_1744 =
									BGL_ENV_ERROR_HANDLER_GET(BgL_env1080z00_3876);
								{	/* Llib/thread.scm 538 */
									obj_t BgL_hds1073z00_1745;

									BgL_hds1073z00_1745 =
										MAKE_STACK_PAIR(BgL_escape1076z00_1742,
										BgL_cell1075z00_3877);
									BGL_ENV_ERROR_HANDLER_SET(BgL_env1080z00_3876,
										BgL_hds1073z00_1745);
									BUNSPEC;
									{	/* Llib/thread.scm 538 */
										obj_t BgL_exitd1081z00_1746;

										BgL_exitd1081z00_1746 =
											BGL_ENV_EXITD_TOP_AS_OBJ(BgL_env1080z00_3876);
										{	/* Llib/thread.scm 538 */
											obj_t BgL_tmp1083z00_1747;

											{	/* Llib/thread.scm 538 */
												obj_t BgL_arg1573z00_1750;

												BgL_arg1573z00_1750 =
													BGL_EXITD_PROTECT(BgL_exitd1081z00_1746);
												BgL_tmp1083z00_1747 =
													MAKE_YOUNG_PAIR(BgL_ohs1072z00_1744,
													BgL_arg1573z00_1750);
											}
											{	/* Llib/thread.scm 538 */

												BGL_EXITD_PROTECT_SET(BgL_exitd1081z00_1746,
													BgL_tmp1083z00_1747);
												BUNSPEC;
												{	/* Llib/thread.scm 538 */
													obj_t BgL_tmp1082z00_1748;

													{
														obj_t BgL_auxz00_7324;

														{	/* Llib/thread.scm 542 */
															obj_t BgL_fun1570z00_1749;

															BgL_fun1570z00_1749 =
																(((BgL_nothreadz00_bglt)
																	COBJECT(BgL_i1071z00_3878))->BgL_bodyz00);
															BgL_auxz00_7324 =
																BGL_PROCEDURE_CALL0(BgL_fun1570z00_1749);
														}
														BgL_tmp1082z00_1748 =
															((((BgL_nothreadz00_bglt)
																	COBJECT(BgL_i1071z00_3878))->
																BgL_endzd2resultzd2) =
															((obj_t) BgL_auxz00_7324), BUNSPEC);
													}
													{	/* Llib/thread.scm 538 */
														bool_t BgL_test2847z00_7330;

														{	/* Llib/thread.scm 538 */
															obj_t BgL_arg1933z00_3139;

															BgL_arg1933z00_3139 =
																BGL_EXITD_PROTECT(BgL_exitd1081z00_1746);
															BgL_test2847z00_7330 = PAIRP(BgL_arg1933z00_3139);
														}
														if (BgL_test2847z00_7330)
															{	/* Llib/thread.scm 538 */
																obj_t BgL_arg1931z00_3140;

																{	/* Llib/thread.scm 538 */
																	obj_t BgL_arg1932z00_3141;

																	BgL_arg1932z00_3141 =
																		BGL_EXITD_PROTECT(BgL_exitd1081z00_1746);
																	BgL_arg1931z00_3140 =
																		CDR(((obj_t) BgL_arg1932z00_3141));
																}
																BGL_EXITD_PROTECT_SET(BgL_exitd1081z00_1746,
																	BgL_arg1931z00_3140);
																BUNSPEC;
															}
														else
															{	/* Llib/thread.scm 538 */
																BFALSE;
															}
													}
													BGL_ENV_ERROR_HANDLER_SET(BgL_env1080z00_3876,
														BgL_ohs1072z00_1744);
													BUNSPEC;
													BgL_res1087z00_1743 = BgL_tmp1082z00_1748;
												}
											}
										}
									}
								}
							}
							POP_ENV_EXIT(BgL_env1080z00_3876);
							return BgL_res1087z00_1743;
						}
					}
				}
		}

	}



/* thread-start!-nothre1234~0 */
	obj_t
		BGl_threadzd2startz12zd2nothre1234ze70zf5zz__threadz00(BgL_nothreadz00_bglt
		BgL_thz00_1726, obj_t BgL_scdz00_1727)
	{
		{	/* Llib/thread.scm 533 */
			{	/* Llib/thread.scm 534 */
				obj_t BgL_threadz00_1730;

				BgL_threadz00_1730 = BGl_za2nothreadzd2currentza2zd2zz__threadz00;
				{	/* Llib/thread.scm 535 */
					obj_t BgL_exitd1067z00_1731;

					BgL_exitd1067z00_1731 = BGL_EXITD_TOP_AS_OBJ();
					{	/* Llib/thread.scm 544 */
						obj_t BgL_zc3z04anonymousza31575ze3z87_3807;

						BgL_zc3z04anonymousza31575ze3z87_3807 =
							MAKE_FX_PROCEDURE
							(BGl_z62zc3z04anonymousza31575ze3ze5zz__threadz00, (int) (0L),
							(int) (1L));
						PROCEDURE_SET(BgL_zc3z04anonymousza31575ze3z87_3807, (int) (0L),
							BgL_threadz00_1730);
						{	/* Llib/thread.scm 535 */
							obj_t BgL_arg1934z00_3136;

							{	/* Llib/thread.scm 535 */
								obj_t BgL_arg1935z00_3137;

								BgL_arg1935z00_3137 = BGL_EXITD_PROTECT(BgL_exitd1067z00_1731);
								BgL_arg1934z00_3136 =
									MAKE_YOUNG_PAIR(BgL_zc3z04anonymousza31575ze3z87_3807,
									BgL_arg1935z00_3137);
							}
							BGL_EXITD_PROTECT_SET(BgL_exitd1067z00_1731, BgL_arg1934z00_3136);
							BUNSPEC;
						}
						{	/* Llib/thread.scm 536 */
							BgL_nothreadz00_bglt BgL_tmp1069z00_1733;

							BGl_za2nothreadzd2currentza2zd2zz__threadz00 =
								((obj_t) BgL_thz00_1726);
							{	/* Llib/thread.scm 538 */
								obj_t BgL_env1080z00_1736;

								BgL_env1080z00_1736 = BGL_CURRENT_DYNAMIC_ENV();
								{	/* Llib/thread.scm 538 */
									obj_t BgL_cell1075z00_1737;

									BgL_cell1075z00_1737 = MAKE_STACK_CELL(BUNSPEC);
									{	/* Llib/thread.scm 538 */
										obj_t BgL_val1079z00_1738;

										BgL_val1079z00_1738 =
											BGl_zc3z04exitza31569ze3ze70z60zz__threadz00
											(BgL_thz00_1726, BgL_cell1075z00_1737,
											BgL_env1080z00_1736);
										if ((BgL_val1079z00_1738 == BgL_cell1075z00_1737))
											{	/* Llib/thread.scm 538 */
												{	/* Llib/thread.scm 538 */
													int BgL_tmpz00_7354;

													BgL_tmpz00_7354 = (int) (0L);
													BGL_SIGSETMASK(BgL_tmpz00_7354);
												}
												{	/* Llib/thread.scm 538 */
													obj_t BgL_arg1568z00_1739;

													BgL_arg1568z00_1739 =
														CELL_REF(((obj_t) BgL_val1079z00_1738));
													((((BgL_nothreadz00_bglt) COBJECT(BgL_thz00_1726))->
															BgL_endzd2exceptionzd2) =
														((obj_t) BgL_arg1568z00_1739), BUNSPEC);
													BGl_raisez00zz__errorz00(BgL_arg1568z00_1739);
											}}
										else
											{	/* Llib/thread.scm 538 */
												BgL_val1079z00_1738;
											}
									}
								}
							}
							BgL_tmp1069z00_1733 = BgL_thz00_1726;
							{	/* Llib/thread.scm 535 */
								bool_t BgL_test2849z00_7361;

								{	/* Llib/thread.scm 535 */
									obj_t BgL_arg1933z00_3145;

									BgL_arg1933z00_3145 =
										BGL_EXITD_PROTECT(BgL_exitd1067z00_1731);
									BgL_test2849z00_7361 = PAIRP(BgL_arg1933z00_3145);
								}
								if (BgL_test2849z00_7361)
									{	/* Llib/thread.scm 535 */
										obj_t BgL_arg1931z00_3146;

										{	/* Llib/thread.scm 535 */
											obj_t BgL_arg1932z00_3147;

											BgL_arg1932z00_3147 =
												BGL_EXITD_PROTECT(BgL_exitd1067z00_1731);
											BgL_arg1931z00_3146 = CDR(((obj_t) BgL_arg1932z00_3147));
										}
										BGL_EXITD_PROTECT_SET(BgL_exitd1067z00_1731,
											BgL_arg1931z00_3146);
										BUNSPEC;
									}
								else
									{	/* Llib/thread.scm 535 */
										BFALSE;
									}
							}
							BGl_za2nothreadzd2currentza2zd2zz__threadz00 = BgL_threadz00_1730;
							return ((obj_t) BgL_tmp1069z00_1733);
						}
					}
				}
			}
		}

	}



/* &<@anonymous:1575> */
	obj_t BGl_z62zc3z04anonymousza31575ze3ze5zz__threadz00(obj_t BgL_envz00_3844)
	{
		{	/* Llib/thread.scm 535 */
			{	/* Llib/thread.scm 544 */
				obj_t BgL_threadz00_3845;

				BgL_threadz00_3845 = PROCEDURE_REF(BgL_envz00_3844, (int) (0L));
				return (BGl_za2nothreadzd2currentza2zd2zz__threadz00 =
					BgL_threadz00_3845, BUNSPEC);
			}
		}

	}



/* &object-print-thread1194 */
	obj_t BGl_z62objectzd2printzd2thread1194z62zz__threadz00(obj_t
		BgL_envz00_3846, obj_t BgL_oz00_3847, obj_t BgL_portz00_3848,
		obj_t BgL_printzd2slotzd2_3849)
	{
		{	/* Llib/thread.scm 378 */
			{	/* Llib/thread.scm 379 */
				obj_t BgL_list1565z00_5019;

				BgL_list1565z00_5019 = MAKE_YOUNG_PAIR(BgL_portz00_3848, BNIL);
				return
					BGl_objectzd2writezd2zz__objectz00(
					((BgL_objectz00_bglt)
						((BgL_threadz00_bglt) BgL_oz00_3847)), BgL_list1565z00_5019);
			}
		}

	}



/* &object-write-thread1192 */
	obj_t BGl_z62objectzd2writezd2thread1192z62zz__threadz00(obj_t
		BgL_envz00_3850, obj_t BgL_oz00_3851, obj_t BgL_portz00_3852)
	{
		{	/* Llib/thread.scm 369 */
			{	/* Llib/thread.scm 370 */
				obj_t BgL_arg1547z00_5021;

				if (PAIRP(BgL_portz00_3852))
					{	/* Llib/thread.scm 370 */
						BgL_arg1547z00_5021 = CAR(BgL_portz00_3852);
					}
				else
					{	/* Llib/thread.scm 370 */
						obj_t BgL_tmpz00_7378;

						BgL_tmpz00_7378 = BGL_CURRENT_DYNAMIC_ENV();
						BgL_arg1547z00_5021 = BGL_ENV_CURRENT_OUTPUT_PORT(BgL_tmpz00_7378);
					}
				{	/* Llib/thread.scm 372 */
					obj_t BgL_zc3z04anonymousza31551ze3z87_5022;

					BgL_zc3z04anonymousza31551ze3z87_5022 =
						MAKE_FX_PROCEDURE(BGl_z62zc3z04anonymousza31551ze3ze5zz__threadz00,
						(int) (0L), (int) (1L));
					PROCEDURE_SET(BgL_zc3z04anonymousza31551ze3z87_5022,
						(int) (0L), ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3851)));
					return
						BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00
						(BgL_arg1547z00_5021, BgL_zc3z04anonymousza31551ze3z87_5022);
				}
			}
		}

	}



/* &<@anonymous:1551> */
	obj_t BGl_z62zc3z04anonymousza31551ze3ze5zz__threadz00(obj_t BgL_envz00_3853)
	{
		{	/* Llib/thread.scm 371 */
			{	/* Llib/thread.scm 372 */
				BgL_threadz00_bglt BgL_oz00_3854;

				BgL_oz00_3854 =
					((BgL_threadz00_bglt) PROCEDURE_REF(BgL_envz00_3853, (int) (0L)));
				{	/* Llib/thread.scm 373 */
					obj_t BgL_arg1552z00_5023;
					obj_t BgL_arg1554z00_5024;

					{	/* Llib/thread.scm 373 */
						obj_t BgL_arg1563z00_5025;

						{	/* Llib/thread.scm 373 */
							obj_t BgL_arg1954z00_5026;
							long BgL_arg1955z00_5027;

							BgL_arg1954z00_5026 = (BGl_za2classesza2z00zz__objectz00);
							{	/* Llib/thread.scm 373 */
								long BgL_arg1956z00_5028;

								BgL_arg1956z00_5028 =
									BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_3854));
								BgL_arg1955z00_5027 = (BgL_arg1956z00_5028 - OBJECT_TYPE);
							}
							BgL_arg1563z00_5025 =
								VECTOR_REF(BgL_arg1954z00_5026, BgL_arg1955z00_5027);
						}
						BgL_arg1552z00_5023 =
							BGl_classzd2namezd2zz__objectz00(BgL_arg1563z00_5025);
					}
					BgL_arg1554z00_5024 =
						(((BgL_threadz00_bglt) COBJECT(BgL_oz00_3854))->BgL_namez00);
					{	/* Llib/thread.scm 373 */
						obj_t BgL_list1555z00_5029;

						{	/* Llib/thread.scm 373 */
							obj_t BgL_arg1558z00_5030;

							{	/* Llib/thread.scm 373 */
								obj_t BgL_arg1559z00_5031;

								{	/* Llib/thread.scm 373 */
									obj_t BgL_arg1561z00_5032;

									{	/* Llib/thread.scm 373 */
										obj_t BgL_arg1562z00_5033;

										BgL_arg1562z00_5033 =
											MAKE_YOUNG_PAIR(BGl_string2427z00zz__threadz00, BNIL);
										BgL_arg1561z00_5032 =
											MAKE_YOUNG_PAIR(BgL_arg1554z00_5024, BgL_arg1562z00_5033);
									}
									BgL_arg1559z00_5031 =
										MAKE_YOUNG_PAIR(BGl_string2428z00zz__threadz00,
										BgL_arg1561z00_5032);
								}
								BgL_arg1558z00_5030 =
									MAKE_YOUNG_PAIR(BgL_arg1552z00_5023, BgL_arg1559z00_5031);
							}
							BgL_list1555z00_5029 =
								MAKE_YOUNG_PAIR(BGl_string2429z00zz__threadz00,
								BgL_arg1558z00_5030);
						}
						return
							BGl_displayza2za2zz__r4_output_6_10_3z00(BgL_list1555z00_5029);
					}
				}
			}
		}

	}



/* &object-display-threa1190 */
	obj_t BGl_z62objectzd2displayzd2threa1190z62zz__threadz00(obj_t
		BgL_envz00_3855, obj_t BgL_oz00_3856, obj_t BgL_portz00_3857)
	{
		{	/* Llib/thread.scm 360 */
			{	/* Llib/thread.scm 361 */
				obj_t BgL_arg1528z00_5035;

				if (PAIRP(BgL_portz00_3857))
					{	/* Llib/thread.scm 361 */
						BgL_arg1528z00_5035 = CAR(BgL_portz00_3857);
					}
				else
					{	/* Llib/thread.scm 361 */
						obj_t BgL_tmpz00_7408;

						BgL_tmpz00_7408 = BGL_CURRENT_DYNAMIC_ENV();
						BgL_arg1528z00_5035 = BGL_ENV_CURRENT_OUTPUT_PORT(BgL_tmpz00_7408);
					}
				{	/* Llib/thread.scm 363 */
					obj_t BgL_zc3z04anonymousza31534ze3z87_5036;

					BgL_zc3z04anonymousza31534ze3z87_5036 =
						MAKE_FX_PROCEDURE(BGl_z62zc3z04anonymousza31534ze3ze5zz__threadz00,
						(int) (0L), (int) (1L));
					PROCEDURE_SET(BgL_zc3z04anonymousza31534ze3z87_5036,
						(int) (0L), ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3856)));
					return
						BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00
						(BgL_arg1528z00_5035, BgL_zc3z04anonymousza31534ze3z87_5036);
				}
			}
		}

	}



/* &<@anonymous:1534> */
	obj_t BGl_z62zc3z04anonymousza31534ze3ze5zz__threadz00(obj_t BgL_envz00_3858)
	{
		{	/* Llib/thread.scm 362 */
			{	/* Llib/thread.scm 363 */
				BgL_threadz00_bglt BgL_oz00_3859;

				BgL_oz00_3859 =
					((BgL_threadz00_bglt) PROCEDURE_REF(BgL_envz00_3858, (int) (0L)));
				{	/* Llib/thread.scm 364 */
					obj_t BgL_arg1537z00_5037;
					obj_t BgL_arg1538z00_5038;

					{	/* Llib/thread.scm 364 */
						obj_t BgL_arg1545z00_5039;

						{	/* Llib/thread.scm 364 */
							obj_t BgL_arg1954z00_5040;
							long BgL_arg1955z00_5041;

							BgL_arg1954z00_5040 = (BGl_za2classesza2z00zz__objectz00);
							{	/* Llib/thread.scm 364 */
								long BgL_arg1956z00_5042;

								BgL_arg1956z00_5042 =
									BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_3859));
								BgL_arg1955z00_5041 = (BgL_arg1956z00_5042 - OBJECT_TYPE);
							}
							BgL_arg1545z00_5039 =
								VECTOR_REF(BgL_arg1954z00_5040, BgL_arg1955z00_5041);
						}
						BgL_arg1537z00_5037 =
							BGl_classzd2namezd2zz__objectz00(BgL_arg1545z00_5039);
					}
					BgL_arg1538z00_5038 =
						(((BgL_threadz00_bglt) COBJECT(BgL_oz00_3859))->BgL_namez00);
					{	/* Llib/thread.scm 364 */
						obj_t BgL_list1539z00_5043;

						{	/* Llib/thread.scm 364 */
							obj_t BgL_arg1540z00_5044;

							{	/* Llib/thread.scm 364 */
								obj_t BgL_arg1541z00_5045;

								{	/* Llib/thread.scm 364 */
									obj_t BgL_arg1542z00_5046;

									{	/* Llib/thread.scm 364 */
										obj_t BgL_arg1543z00_5047;

										BgL_arg1543z00_5047 =
											MAKE_YOUNG_PAIR(BGl_string2427z00zz__threadz00, BNIL);
										BgL_arg1542z00_5046 =
											MAKE_YOUNG_PAIR(BgL_arg1538z00_5038, BgL_arg1543z00_5047);
									}
									BgL_arg1541z00_5045 =
										MAKE_YOUNG_PAIR(BGl_string2428z00zz__threadz00,
										BgL_arg1542z00_5046);
								}
								BgL_arg1540z00_5044 =
									MAKE_YOUNG_PAIR(BgL_arg1537z00_5037, BgL_arg1541z00_5045);
							}
							BgL_list1539z00_5043 =
								MAKE_YOUNG_PAIR(BGl_string2429z00zz__threadz00,
								BgL_arg1540z00_5044);
						}
						return
							BGl_displayza2za2zz__r4_output_6_10_3z00(BgL_list1539z00_5043);
					}
				}
			}
		}

	}



/* &tb-current-thread-no1184 */
	obj_t BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00(obj_t
		BgL_envz00_3860, obj_t BgL_tbz00_3861)
	{
		{	/* Llib/thread.scm 344 */
			return BGl_za2nothreadzd2currentza2zd2zz__threadz00;
		}

	}



/* &tb-make-thread-nothr1182 */
	BgL_threadz00_bglt BGl_z62tbzd2makezd2threadzd2nothr1182zb0zz__threadz00(obj_t
		BgL_envz00_3862, obj_t BgL_tbz00_3863, obj_t BgL_bodyz00_3864,
		obj_t BgL_namez00_3865)
	{
		{	/* Llib/thread.scm 336 */
			{	/* Llib/thread.scm 337 */
				BgL_nothreadz00_bglt BgL_new1062z00_5050;

				{	/* Llib/thread.scm 339 */
					BgL_nothreadz00_bglt BgL_new1060z00_5051;

					BgL_new1060z00_5051 =
						((BgL_nothreadz00_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_nothreadz00_bgl))));
					{	/* Llib/thread.scm 339 */
						long BgL_arg1527z00_5052;

						BgL_arg1527z00_5052 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1060z00_5051), BgL_arg1527z00_5052);
					}
					BgL_new1062z00_5050 = BgL_new1060z00_5051;
				}
				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1062z00_5050)))->BgL_namez00) =
					((obj_t) BgL_namez00_3865), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->BgL_bodyz00) =
					((obj_t) BgL_bodyz00_3864), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->
						BgL_z52specificz52) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->
						BgL_z52cleanupz52) = ((obj_t) BFALSE), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->
						BgL_endzd2resultzd2) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->
						BgL_endzd2exceptionzd2) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_5050))->
						BgL_z52namez52) =
					((obj_t) BGl_string2318z00zz__threadz00), BUNSPEC);
				{	/* Llib/thread.scm 337 */
					obj_t BgL_fun1526z00_5053;

					BgL_fun1526z00_5053 =
						BGl_classzd2constructorzd2zz__objectz00
						(BGl_nothreadz00zz__threadz00);
					BGL_PROCEDURE_CALL1(BgL_fun1526z00_5053,
						((obj_t) BgL_new1062z00_5050));
				}
				return ((BgL_threadz00_bglt) BgL_new1062z00_5050);
			}
		}

	}



/* imported-modules-init */
	obj_t BGl_importedzd2moduleszd2initz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_modulezd2initializa7ationz75zz__errorz00(88804785L,
				BSTRING_TO_STRING(BGl_string2258z00zz__threadz00));
			return
				BGl_modulezd2initializa7ationz75zz__objectz00(475449627L,
				BSTRING_TO_STRING(BGl_string2258z00zz__threadz00));
		}

	}

#ifdef __cplusplus
}
#endif
