/*===========================================================================*/
/*   (Llib/thread.scm)                                                       */
/*   Bigloo (4.5b)                                                           */
/*   Inria -- Sophia Antipolis (c)       Fri Dec 22 05:17:06 PM CET 2023     */
/*===========================================================================*/
/* COMPILATION: (/home/serrano/prgm/project/bigloo/bigloo/bin/bigloo -ldopt -L/home/serrano/prgm/project/bigloo/bigloo/libbacktrace/home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.5b  -srfi enable-gmp -srfi bigloo-unsafe -O3 -fcfa-arithmetic -q -lib-dir /home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.5b -rm -copt -w -lib-dir /home/serrano/prgm/project/bigloo/bigloo/lib/bigloo/4.5b -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_z62threadzd2killz12zd2nothrea1241z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62threadzd2namezd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	extern obj_t bgl_make_nil_condvar(void);
	static obj_t BGl_z52currentzd2threadz80zz__threadz00(void);
	static obj_t BGl_z62threadzd2namezd2setz12zd2not1253za2zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_tbzd2condvarzd2initializa7ez12zb5zz__threadz00
		(BgL_threadzd2backendzd2_bglt, obj_t);
	static obj_t BGl_z62threadzd2joinz12za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl__makezd2mutexzd2zz__threadz00(obj_t, obj_t);
	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_z62threadzd2specificzb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_requirezd2initializa7ationz75zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_withzd2lockzd2zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_raisez00zz__errorz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2cleanupzd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	extern obj_t BGl_typezd2errorzd2zz__errorz00(obj_t, obj_t, obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL bool_t
		BGl_conditionzd2variablezd2broadcastz12z12zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00(obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_makezd2mutexzd2zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_threadzd2sleepz12zc0zz__threadz00(obj_t);
	extern obj_t BGl_za2classesza2z00zz__objectz00;
	static obj_t BGl_z62threadzd2parameterzb0zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_registerzd2genericz12zc0zz__objectz00(obj_t, obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00(obj_t,
		obj_t, 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);
	BGL_EXPORTED_DECL obj_t
		BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62conditionzd2variablezd2namez62zz__threadz00(obj_t, obj_t);
	extern obj_t bgl_make_nil_mutex(void);
	BGL_EXPORTED_DECL obj_t BGl_withzd2timedzd2lockz00zz__threadz00(obj_t, int,
		obj_t);
	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);
	BGL_EXPORTED_DECL obj_t BGl_currentzd2threadzd2backendz00zz__threadz00(void);
	static BgL_nothreadzd2backendzd2_bglt
		BGl_za2nothreadzd2backendza2zd2zz__threadz00;
	static obj_t BGl_z62currentzd2dynamiczd2envz62zz__threadz00(obj_t);
	static obj_t BGl_z62threadzd2name1217zb0zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_assqz00zz__r4_pairs_and_lists_6_3z00(obj_t, obj_t);
	static obj_t BGl_genericzd2initzd2zz__threadz00(void);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2namezd2zz__threadz00(obj_t);
	static obj_t BGl_z62mutexzd2nilzb0zz__threadz00(obj_t);
	static obj_t BGl__makezd2spinlockzd2zz__threadz00(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);
	BGL_EXPORTED_DECL obj_t
		BGl_currentzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt);
	static obj_t BGl_objectzd2initzd2zz__threadz00(void);
	extern obj_t BGl_2za2za2zz__r4_numbers_6_5z00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2specific1208zb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62defaultzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2startz12zd2nothre1233z70zz__threadz00(obj_t,
		obj_t, obj_t);
	extern double BGl_numberzd2ze3flonumz31zz__r4_numbers_6_5z00(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_z62mutexzd2namezb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62objectzd2writezd2thread1192z62zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2terminatez12zd2no1239z70zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2killz12zc0zz__threadz00(BgL_threadz00_bglt, int);
	static obj_t BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00(obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2specificzd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	extern obj_t bstring_to_symbol(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31411ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31403ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2terminatez12za2zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL bool_t BGl_dynamiczd2envzf3z21zz__threadz00(obj_t);
	static obj_t BGl_z62threadzd2startz12za2zz__threadz00(obj_t, obj_t, obj_t);
	extern bool_t BGl_isazf3zf3zz__objectz00(obj_t, obj_t);
	static obj_t BGl_z62getzd2threadzd2backendz62zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2nilzd2zz__threadz00(void);
	static obj_t BGl_z62mutexzd2unlockz12za2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2cleanupzb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62threadzd2initializa7ez12z05zz__threadz00(obj_t, obj_t);
	static obj_t BGl_methodzd2initzd2zz__threadz00(void);
	static obj_t BGl_z62threadzd2yieldz12za2zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_threadzd2namezd2zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62zc3z04anonymousza31413ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31405ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_makezd2spinlockzd2zz__threadz00(obj_t);
	static obj_t BGl_z62threadzd2initializa7ez121195z05zz__threadz00(obj_t,
		obj_t);
	extern obj_t BGl_objectzd2writezd2zz__objectz00(BgL_objectz00_bglt, obj_t);
	static obj_t BGl_z62tbzd2currentzd2threadz62zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DEF obj_t BGl_nothreadz00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_threadzd2parameterzd2setz12z12zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL bool_t BGl_mutexzf3zf3zz__threadz00(obj_t);
	static obj_t BGl_z62tbzd2makezd2thread1177z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t BGl_currentzd2dynamiczd2envz00zz__threadz00(void);
	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);
	static obj_t BGl_z62zc3z04anonymousza31440ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62objectzd2displayzd2threa1190z62zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62currentzd2threadzb0zz__threadz00(obj_t);
	static obj_t BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00(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_DEF obj_t BGl_threadzd2backendzd2zz__threadz00 = BUNSPEC;
	extern obj_t BGl_callzd2virtualzd2setterz00zz__objectz00(BgL_objectz00_bglt,
		int, obj_t);
	static obj_t BGl_z62threadzd2namezd2nothread1251z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2specificzd2noth1243z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2parameterzd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62z52userzd2currentzd2thread1226z30zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2cleanupzd2zz__threadz00(BgL_threadz00_bglt);
	BGL_EXPORTED_DECL obj_t
		BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31426ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2setz121215z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62z52userzd2threadzd2yieldz121230z22zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62z52userzd2currentzd2threadz30zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_classzd2constructorzd2zz__objectz00(obj_t);
	static obj_t BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_conditionzd2variablezd2nilz00zz__threadz00(void);
	static obj_t BGl_z62zc3z04anonymousza31354ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_za2threadzd2backendsza2zd2zz__threadz00 = BUNSPEC;
	extern obj_t bgl_remq_bang(obj_t, obj_t);
	extern obj_t BGl_exitz00zz__errorz00(obj_t);
	static obj_t BGl_z62threadzd2joinz121202za2zz__threadz00(obj_t, obj_t, 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);
	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 *);
	extern obj_t BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t BGl_defaultzd2threadzd2backendz00zz__threadz00(void);
	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_z62zc3z04anonymousza31461ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31526ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_symbol2202z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2203z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2statezd2zz__threadz00(obj_t);
	static obj_t BGl_symbol2208z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_currentzd2threadzd2zz__threadz00(void);
	BGL_EXPORTED_DECL obj_t
		BGl_conditionzd2variablezd2namez00zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31454ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31365ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2nothr1247z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_symbol2212z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2216z00zz__threadz00 = BUNSPEC;
	static BgL_nothreadz00_bglt BGl_z62lambda1420z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t, obj_t, obj_t, obj_t, obj_t);
	static obj_t BGl_z62threadzd2specificzd2setz121210z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static BgL_nothreadz00_bglt BGl_z62lambda1424z62zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31447ze3ze5zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2startz12zc0zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_cnstzd2initzd2zz__threadz00(void);
	static obj_t BGl_symbol2303z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2306z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2226z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62tbzd2currentzd2thread1179z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2308z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2228z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2309z00zz__threadz00 = BUNSPEC;
	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);
	BGL_EXPORTED_DECL obj_t BGl_mutexzd2unlockz12zc0zz__threadz00(obj_t);
	static obj_t BGl_gczd2rootszd2initz00zz__threadz00(void);
	static obj_t BGl_z62lambda1432z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31391ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1433z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1438z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62mutexzf3z91zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1439z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62threadzd2killz12za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_symbol2310z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t BGl_threadzd2yieldz12zc0zz__threadz00(void);
	static obj_t BGl_symbol2311z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2312z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62conditionzd2variablezf3z43zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2232z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2313z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2314z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62conditionzd2variablezd2broadcastz12z70zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_symbol2315z00zz__threadz00 = BUNSPEC;
	static obj_t BGl__makezd2threadzd2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2316z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2317z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2237z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2318z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2sleepz12za2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2319z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62zc3z04anonymousza31392ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	static BgL_threadzd2backendzd2_bglt BGl_z62lambda1361z62zz__threadz00(obj_t,
		obj_t);
	static BgL_threadzd2backendzd2_bglt BGl_z62lambda1363z62zz__threadz00(obj_t);
	static obj_t BGl_z62lambda1445z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1446z62zz__threadz00(obj_t, obj_t, obj_t);
	extern obj_t BGl_objectz00zz__objectz00;
	BGL_EXPORTED_DECL obj_t BGl_getzd2threadzd2backendz00zz__threadz00(obj_t);
	static obj_t BGl_z62lambda1369z62zz__threadz00(obj_t, obj_t);
	extern obj_t BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(obj_t, obj_t);
	static obj_t BGl_symbol2320z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2321z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62dynamiczd2envzf3z43zz__threadz00(obj_t, obj_t);
	static obj_t BGl_symbol2242z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2killz121206za2zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_symbol2247z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2169z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62lambda1370z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1452z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1453z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31547ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31377ze3ze5zz__threadz00(obj_t, obj_t);
	static BgL_threadz00_bglt BGl_z62lambda1375z62zz__threadz00(obj_t);
	static obj_t BGl_z62threadzd2specificzd2setz121245z70zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2initializa7ez12z67zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_z62lambda1459z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2cleanup1213zb0zz__threadz00(obj_t, obj_t);
	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_symbol2176z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_symbol2257z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2joinz12zd2nothrea1237z70zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_symbol2178z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62lambda1460z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1466z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1385z62zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62lambda1467z62zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62lambda1386z62zz__threadz00(obj_t, obj_t, obj_t);
	extern BGL_LONGLONG_T bgl_current_nanoseconds(void);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2namezd2setz12z12zz__threadz00(BgL_threadz00_bglt, obj_t);
	static obj_t BGl_symbol2261z00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL BgL_threadz00_bglt BGl_makezd2threadzd2zz__threadz00(obj_t,
		obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2startzd2joinablez12z12zz__threadz00(BgL_threadz00_bglt);
	BGL_EXPORTED_DECL bool_t
		BGl_conditionzd2variablezd2signalz12z12zz__threadz00(obj_t);
	static obj_t
		BGl_zc3z04exitza31560ze3ze70z60zz__threadz00(BgL_nothreadz00_bglt, obj_t,
		obj_t);
	static obj_t BGl_symbol2187z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62threadzd2startz121198za2zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00(obj_t, obj_t,
		obj_t);
	extern obj_t BGl_gensymz00zz__r4_symbols_6_4z00(obj_t);
	static obj_t BGl_z62threadzd2namezd2setz121219z70zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl_z62zc3z04anonymousza31565ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31468ze3ze5zz__threadz00(obj_t);
	static obj_t BGl_z62zc3z04anonymousza31387ze3ze5zz__threadz00(obj_t);
	static BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1475z62zz__threadz00(obj_t,
		obj_t);
	static BgL_nothreadzd2backendzd2_bglt
		BGl_z62lambda1477z62zz__threadz00(obj_t);
	extern obj_t BGl_genericzd2addzd2methodz12z12zz__objectz00(obj_t, obj_t,
		obj_t, obj_t);
	extern obj_t BGl_bigloozd2typezd2errorz00zz__errorz00(obj_t, obj_t, obj_t);
	static obj_t BGl_symbol2196z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62threadzd2cleanupzd2setz12zd21249za2zz__threadz00(obj_t,
		obj_t, obj_t);
	static obj_t BGl_symbol2198z00zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62conditionzd2variablezd2nilz62zz__threadz00(obj_t);
	BGL_EXPORTED_DECL BgL_threadz00_bglt
		BGl_tbzd2makezd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt, obj_t,
		obj_t);
	static obj_t BGl_z62mutexzd2statezb0zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62threadzd2startzd2joinabl1200z62zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl_z62objectzd2printzd2thread1194z62zz__threadz00(obj_t, obj_t,
		obj_t, obj_t);
	static obj_t BGl_z62conditionzd2variablezd2signalz12z70zz__threadz00(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);
	static obj_t BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31397ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_za2nothreadzd2currentza2zd2zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t
		BGl_makezd2conditionzd2variablez00zz__threadz00(obj_t);
	static obj_t BGl_z62defaultzd2threadzd2backendz62zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t BGl_threadzd2parameterzd2zz__threadz00(obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_threadzd2terminatez12zc0zz__threadz00(BgL_threadz00_bglt);
	static obj_t BGl_za2mutexzd2nilza2zd2zz__threadz00 = BUNSPEC;
	static obj_t BGl_z62withzd2lockzb0zz__threadz00(obj_t, obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31479ze3ze5zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00(obj_t, obj_t,
		obj_t);
	static obj_t BGl__conditionzd2variablezd2waitz12z12zz__threadz00(obj_t,
		obj_t);
	static obj_t BGl__mutexzd2lockz12zc0zz__threadz00(obj_t, obj_t);
	BGL_EXPORTED_DEF obj_t BGl_threadz00zz__threadz00 = BUNSPEC;
	BGL_EXPORTED_DECL obj_t
		BGl_defaultzd2threadzd2backendzd2setz12zc0zz__threadz00
		(BgL_threadzd2backendzd2_bglt);
	BGL_EXPORTED_DECL bool_t BGl_conditionzd2variablezf3z21zz__threadz00(obj_t);
	static obj_t BGl_z62threadzd2terminatez121204za2zz__threadz00(obj_t, obj_t);
	static obj_t BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00(obj_t,
		obj_t, obj_t);
	BGL_EXPORTED_DECL obj_t
		BGl_tbzd2currentzd2threadz00zz__threadz00(BgL_threadzd2backendzd2_bglt);
	static obj_t BGl_z62threadzd2startzd2joinabl1235z62zz__threadz00(obj_t,
		obj_t);
	static obj_t *__cnst;


	   
		 
		DEFINE_STRING(BGl_string2204z00zz__threadz00,
		BgL_bgl_string2204za700za7za7_2376za7, "__thread", 8);
	      DEFINE_STRING(BGl_string2209z00zz__threadz00,
		BgL_bgl_string2209za700za7za7_2377za7, "obj", 3);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2waitz12zd2envzc0zz__threadz00,
		BgL_bgl__conditionza7d2var2378za7, opt_generic_entry,
		BGl__conditionzd2variablezd2waitz12z12zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2200z00zz__threadz00,
		BgL_bgl_za762lambda1363za7622379z00, BGl_z62lambda1363z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2201z00zz__threadz00,
		BgL_bgl_za762lambda1361za7622380z00, BGl_z62lambda1361z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2205z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2381za7,
		BGl_z62zc3z04anonymousza31387ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2206z00zz__threadz00,
		BgL_bgl_za762lambda1386za7622382z00, BGl_z62lambda1386z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2207z00zz__threadz00,
		BgL_bgl_za762lambda1385za7622383z00, BGl_z62lambda1385z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2213z00zz__threadz00,
		BgL_bgl_string2213za700za7za7_2384za7, "specific", 8);
	      DEFINE_STRING(BGl_string2217z00zz__threadz00,
		BgL_bgl_string2217za700za7za7_2385za7, "cleanup", 7);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
		BgL_bgl_za762currentza7d2thr2386z00,
		BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_defaultzd2threadzd2backendzd2setz12zd2envz12zz__threadz00,
		BgL_bgl_za762defaultza7d2thr2387z00,
		BGl_z62defaultzd2threadzd2backendzd2setz12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezf3zd2envzf3zz__threadz00,
		BgL_bgl_za762conditionza7d2v2388z00,
		BGl_z62conditionzd2variablezf3z43zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2210z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2389za7,
		BGl_z62zc3z04anonymousza31392ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2211z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2390za7,
		BGl_z62zc3z04anonymousza31391ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2namezd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2name2391z00, BGl_z62threadzd2namezb0zz__threadz00,
		0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2300z00zz__threadz00,
		BgL_bgl_string2300za700za7za7_2392za7, "%user-thread-sleep!1228", 23);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2214z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2393za7,
		BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2215z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2394za7,
		BGl_z62zc3z04anonymousza31397ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2302z00zz__threadz00,
		BgL_bgl_string2302za700za7za7_2395za7, "%user-thread-yield!1230", 23);
	      DEFINE_STRING(BGl_string2304z00zz__threadz00,
		BgL_bgl_string2304za700za7za7_2396za7, "thread-sleep!", 13);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2218z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2397za7,
		BGl_z62zc3z04anonymousza31403ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2305z00zz__threadz00,
		BgL_bgl_string2305za700za7za7_2398za7, "date, real, or integer", 22);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2219z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2399za7,
		BGl_z62zc3z04anonymousza31405ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2307z00zz__threadz00,
		BgL_bgl_string2307za700za7za7_2400za7, "No method for this object", 25);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2spinlockzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2spinlock2401za7, opt_generic_entry,
		BGl__makezd2spinlockzd2zz__threadz00, BFALSE, -1);
	      DEFINE_STRING(BGl_string2227z00zz__threadz00,
		BgL_bgl_string2227za700za7za7_2402za7, "body", 4);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2220z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2403za7,
		BGl_z62zc3z04anonymousza31411ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2301z00zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2404za7,
		BGl_z62z52userzd2threadzd2yieldz121230z22zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2221z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2405za7,
		BGl_z62zc3z04anonymousza31413ze3ze5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2222z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2406za7,
		BGl_z62zc3z04anonymousza31377ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2223z00zz__threadz00,
		BgL_bgl_za762lambda1375za7622407z00, BGl_z62lambda1375z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2224z00zz__threadz00,
		BgL_bgl_za762lambda1433za7622408z00, BGl_z62lambda1433z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2225z00zz__threadz00,
		BgL_bgl_za762lambda1432za7622409z00, BGl_z62lambda1432z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2233z00zz__threadz00,
		BgL_bgl_string2233za700za7za7_2410za7, "%specific", 9);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2cleanupzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2411z00,
		BGl_z62threadzd2cleanupzb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2229z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2412za7,
		BGl_z62zc3z04anonymousza31440ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2238z00zz__threadz00,
		BgL_bgl_string2238za700za7za7_2413za7, "%cleanup", 8);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2230z00zz__threadz00,
		BgL_bgl_za762lambda1439za7622414z00, BGl_z62lambda1439z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2231z00zz__threadz00,
		BgL_bgl_za762lambda1438za7622415z00, BGl_z62lambda1438z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2234z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2416za7,
		BGl_z62zc3z04anonymousza31447ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2235z00zz__threadz00,
		BgL_bgl_za762lambda1446za7622417z00, BGl_z62lambda1446z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2322z00zz__threadz00,
		BgL_bgl_string2322za700za7za7_2418za7, "&tb-make-thread", 15);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2236z00zz__threadz00,
		BgL_bgl_za762lambda1445za7622419z00, BGl_z62lambda1445z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2323z00zz__threadz00,
		BgL_bgl_string2323za700za7za7_2420za7, "&tb-current-thread", 18);
	      DEFINE_STRING(BGl_string2162z00zz__threadz00,
		BgL_bgl_string2162za700za7za7_2421za7, "nothread", 8);
	      DEFINE_STRING(BGl_string2243z00zz__threadz00,
		BgL_bgl_string2243za700za7za7_2422za7, "end-result", 10);
	      DEFINE_STRING(BGl_string2324z00zz__threadz00,
		BgL_bgl_string2324za700za7za7_2423za7, "&tb-mutex-initialize!", 21);
	      DEFINE_STRING(BGl_string2163z00zz__threadz00,
		BgL_bgl_string2163za700za7za7_2424za7,
		"/tmp/bigloo/runtime/Llib/thread.scm", 35);
	      DEFINE_STRING(BGl_string2325z00zz__threadz00,
		BgL_bgl_string2325za700za7za7_2425za7, "&tb-condvar-initialize!", 23);
	      DEFINE_STRING(BGl_string2164z00zz__threadz00,
		BgL_bgl_string2164za700za7za7_2426za7, "&current-thread-backend-set!", 28);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2239z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2427za7,
		BGl_z62zc3z04anonymousza31454ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2326z00zz__threadz00,
		BgL_bgl_string2326za700za7za7_2428za7, "&thread-initialize!", 19);
	      DEFINE_STRING(BGl_string2165z00zz__threadz00,
		BgL_bgl_string2165za700za7za7_2429za7, "thread-backend", 14);
	      DEFINE_STRING(BGl_string2327z00zz__threadz00,
		BgL_bgl_string2327za700za7za7_2430za7, "&thread-start!", 14);
	      DEFINE_STRING(BGl_string2166z00zz__threadz00,
		BgL_bgl_string2166za700za7za7_2431za7, "&default-thread-backend-set!", 28);
	      DEFINE_STRING(BGl_string2328z00zz__threadz00,
		BgL_bgl_string2328za700za7za7_2432za7, "&thread-start-joinable!", 23);
	      DEFINE_STRING(BGl_string2167z00zz__threadz00,
		BgL_bgl_string2167za700za7za7_2433za7, "&get-thread-backend", 19);
	      DEFINE_STRING(BGl_string2248z00zz__threadz00,
		BgL_bgl_string2248za700za7za7_2434za7, "end-exception", 13);
	      DEFINE_STRING(BGl_string2329z00zz__threadz00,
		BgL_bgl_string2329za700za7za7_2435za7, "&thread-join!", 13);
	      DEFINE_STRING(BGl_string2168z00zz__threadz00,
		BgL_bgl_string2168za700za7za7_2436za7, "bstring", 7);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2startz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2star2437z00, va_generic_entry,
		BGl_z62threadzd2startz12za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2threadzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2threadza7d2438z00, opt_generic_entry,
		BGl__makezd2threadzd2zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2240z00zz__threadz00,
		BgL_bgl_za762lambda1453za7622439z00, BGl_z62lambda1453z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2241z00zz__threadz00,
		BgL_bgl_za762lambda1452za7622440z00, BGl_z62lambda1452z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2330z00zz__threadz00,
		BgL_bgl_string2330za700za7za7_2441za7, "&thread-terminate!", 18);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2244z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2442za7,
		BGl_z62zc3z04anonymousza31461ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2331z00zz__threadz00,
		BgL_bgl_string2331za700za7za7_2443za7, "&thread-kill!", 13);
	      DEFINE_STRING(BGl_string2170z00zz__threadz00,
		BgL_bgl_string2170za700za7za7_2444za7, "thread", 6);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2245z00zz__threadz00,
		BgL_bgl_za762lambda1460za7622445z00, BGl_z62lambda1460z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2332z00zz__threadz00,
		BgL_bgl_string2332za700za7za7_2446za7, "&thread-specific", 16);
	      DEFINE_STRING(BGl_string2171z00zz__threadz00,
		BgL_bgl_string2171za700za7za7_2447za7, "_make-thread", 12);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2246z00zz__threadz00,
		BgL_bgl_za762lambda1459za7622448z00, BGl_z62lambda1459z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2333z00zz__threadz00,
		BgL_bgl_string2333za700za7za7_2449za7, "&thread-specific-set!", 21);
	      DEFINE_STRING(BGl_string2172z00zz__threadz00,
		BgL_bgl_string2172za700za7za7_2450za7, "procedure", 9);
	      DEFINE_STRING(BGl_string2253z00zz__threadz00,
		BgL_bgl_string2253za700za7za7_2451za7, "%name", 5);
	      DEFINE_STRING(BGl_string2334z00zz__threadz00,
		BgL_bgl_string2334za700za7za7_2452za7, "&thread-cleanup", 15);
	      DEFINE_STRING(BGl_string2173z00zz__threadz00,
		BgL_bgl_string2173za700za7za7_2453za7, "&thread-parameter", 17);
	      DEFINE_STRING(BGl_string2335z00zz__threadz00,
		BgL_bgl_string2335za700za7za7_2454za7, "&thread-cleanup-set!", 20);
	      DEFINE_STRING(BGl_string2174z00zz__threadz00,
		BgL_bgl_string2174za700za7za7_2455za7, "symbol", 6);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2249z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2456za7,
		BGl_z62zc3z04anonymousza31468ze3ze5zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2336z00zz__threadz00,
		BgL_bgl_string2336za700za7za7_2457za7, "&thread-name", 12);
	      DEFINE_STRING(BGl_string2175z00zz__threadz00,
		BgL_bgl_string2175za700za7za7_2458za7, "&thread-parameter-set!", 22);
	      DEFINE_STRING(BGl_string2337z00zz__threadz00,
		BgL_bgl_string2337za700za7za7_2459za7, "&thread-name-set!", 17);
	      DEFINE_STRING(BGl_string2338z00zz__threadz00,
		BgL_bgl_string2338za700za7za7_2460za7, "&%user-current-thread", 21);
	      DEFINE_STRING(BGl_string2177z00zz__threadz00,
		BgL_bgl_string2177za700za7za7_2461za7, "mutex", 5);
	      DEFINE_STRING(BGl_string2339z00zz__threadz00,
		BgL_bgl_string2339za700za7za7_2462za7, "&%user-thread-sleep!", 20);
	      DEFINE_STRING(BGl_string2179z00zz__threadz00,
		BgL_bgl_string2179za700za7za7_2463za7, "spinlock", 8);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2250z00zz__threadz00,
		BgL_bgl_za762lambda1467za7622464z00, BGl_z62lambda1467z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2251z00zz__threadz00,
		BgL_bgl_za762lambda1466za7622465z00, BGl_z62lambda1466z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2340z00zz__threadz00,
		BgL_bgl_string2340za700za7za7_2466za7, "&%user-thread-yield!", 20);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2254z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2467za7,
		BGl_z62zc3z04anonymousza31426ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2180z00zz__threadz00,
		BgL_bgl_string2180za700za7za7_2468za7, "&mutex-name", 11);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2255z00zz__threadz00,
		BgL_bgl_za762lambda1424za7622469z00, BGl_z62lambda1424z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2342z00zz__threadz00,
		BgL_bgl_string2342za700za7za7_2470za7, "tb-make-thread", 14);
	      DEFINE_STRING(BGl_string2181z00zz__threadz00,
		BgL_bgl_string2181za700za7za7_2471za7, "_mutex-lock!", 12);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2256z00zz__threadz00,
		BgL_bgl_za762lambda1420za7622472z00, BGl_z62lambda1420z62zz__threadz00, 0L,
		BUNSPEC, 7);
	      DEFINE_STRING(BGl_string2262z00zz__threadz00,
		BgL_bgl_string2262za700za7za7_2473za7, "nothread-backend", 16);
	      DEFINE_STRING(BGl_string2182z00zz__threadz00,
		BgL_bgl_string2182za700za7za7_2474za7, "bint", 4);
	      DEFINE_STRING(BGl_string2263z00zz__threadz00,
		BgL_bgl_string2263za700za7za7_2475za7, "", 0);
	      DEFINE_STRING(BGl_string2344z00zz__threadz00,
		BgL_bgl_string2344za700za7za7_2476za7, "tb-current-thread", 17);
	extern obj_t BGl_objectzd2writezd2envz00zz__objectz00;
	   
		 
		DEFINE_STRING(BGl_string2183z00zz__threadz00,
		BgL_bgl_string2183za700za7za7_2477za7, "&mutex-unlock!", 14);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2258z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2478za7,
		BGl_z62zc3z04anonymousza31479ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2264z00zz__threadz00,
		BgL_bgl_string2264za700za7za7_2479za7, "bigloo", 6);
	      DEFINE_STRING(BGl_string2184z00zz__threadz00,
		BgL_bgl_string2184za700za7za7_2480za7, "&mutex-state", 12);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2259z00zz__threadz00,
		BgL_bgl_za762lambda1477za7622481z00, BGl_z62lambda1477z62zz__threadz00, 0L,
		BUNSPEC, 0);
	      DEFINE_STRING(BGl_string2346z00zz__threadz00,
		BgL_bgl_string2346za700za7za7_2482za7, "object-display", 14);
	      DEFINE_STRING(BGl_string2185z00zz__threadz00,
		BgL_bgl_string2185za700za7za7_2483za7, "&with-lock", 10);
	      DEFINE_STRING(BGl_string2266z00zz__threadz00,
		BgL_bgl_string2266za700za7za7_2484za7, "tb-make-thread1177", 18);
	      DEFINE_STRING(BGl_string2186z00zz__threadz00,
		BgL_bgl_string2186za700za7za7_2485za7, "&with-timed-lock", 16);
	      DEFINE_STRING(BGl_string2348z00zz__threadz00,
		BgL_bgl_string2348za700za7za7_2486za7, "object-write", 12);
	      DEFINE_STRING(BGl_string2268z00zz__threadz00,
		BgL_bgl_string2268za700za7za7_2487za7, "tb-current-thread1179", 21);
	      DEFINE_STRING(BGl_string2188z00zz__threadz00,
		BgL_bgl_string2188za700za7za7_2488za7, "condition-variable", 18);
	      DEFINE_STRING(BGl_string2189z00zz__threadz00,
		BgL_bgl_string2189za700za7za7_2489za7, "&condition-variable-name", 24);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2260z00zz__threadz00,
		BgL_bgl_za762lambda1475za7622490z00, BGl_z62lambda1475z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2341z00zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2491za7,
		BGl_z62tbzd2makezd2threadzd2nothr1182zb0zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2343z00zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72492za7,
		BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2350z00zz__threadz00,
		BgL_bgl_string2350za700za7za7_2493za7, "object-print", 12);
	      DEFINE_STRING(BGl_string2270z00zz__threadz00,
		BgL_bgl_string2270za700za7za7_2494za7, "tb-mutex-initialize!1185", 24);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2345z00zz__threadz00,
		BgL_bgl_za762objectza7d2disp2495z00, va_generic_entry,
		BGl_z62objectzd2displayzd2threa1190z62zz__threadz00, BUNSPEC, -2);
	      DEFINE_STRING(BGl_string2190z00zz__threadz00,
		BgL_bgl_string2190za700za7za7_2496za7, "condvar", 7);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2265z00zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2497za7,
		BGl_z62tbzd2makezd2thread1177z62zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_STRING(BGl_string2352z00zz__threadz00,
		BgL_bgl_string2352za700za7za7_2498za7, "thread-start!", 13);
	      DEFINE_STRING(BGl_string2191z00zz__threadz00,
		BgL_bgl_string2191za700za7za7_2499za7, "_condition-variable-wait!", 25);
	      DEFINE_STRING(BGl_string2272z00zz__threadz00,
		BgL_bgl_string2272za700za7za7_2500za7, "tb-condvar-initializ1187", 24);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2347z00zz__threadz00,
		BgL_bgl_za762objectza7d2writ2501z00, va_generic_entry,
		BGl_z62objectzd2writezd2thread1192z62zz__threadz00, BUNSPEC, -2);
	      DEFINE_STRING(BGl_string2192z00zz__threadz00,
		BgL_bgl_string2192za700za7za7_2502za7, "&condition-variable-signal!", 27);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2267z00zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72503za7,
		BGl_z62tbzd2currentzd2thread1179z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2354z00zz__threadz00,
		BgL_bgl_string2354za700za7za7_2504za7, "thread-start-joinable!", 22);
	      DEFINE_STRING(BGl_string2193z00zz__threadz00,
		BgL_bgl_string2193za700za7za7_2505za7, "&condition-variable-broadcast!",
		30);
	      DEFINE_STRING(BGl_string2274z00zz__threadz00,
		BgL_bgl_string2274za700za7za7_2506za7, "thread-initialize!1195", 22);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2349z00zz__threadz00,
		BgL_bgl_za762objectza7d2prin2507z00,
		BGl_z62objectzd2printzd2thread1194z62zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2269z00zz__threadz00,
		BgL_bgl_za762tbza7d2mutexza7d22508za7,
		BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2356z00zz__threadz00,
		BgL_bgl_string2356za700za7za7_2509za7, "thread-join!", 12);
	      DEFINE_STRING(BGl_string2276z00zz__threadz00,
		BgL_bgl_string2276za700za7za7_2510za7, "thread-start!1198", 17);
	      DEFINE_STRING(BGl_string2358z00zz__threadz00,
		BgL_bgl_string2358za700za7za7_2511za7, "thread-terminate!", 17);
	      DEFINE_STRING(BGl_string2197z00zz__threadz00,
		BgL_bgl_string2197za700za7za7_2512za7, "name", 4);
	      DEFINE_STRING(BGl_string2278z00zz__threadz00,
		BgL_bgl_string2278za700za7za7_2513za7, "thread-start-joinabl1200", 24);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2351z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2514z00, va_generic_entry,
		BGl_z62threadzd2startz12zd2nothre1233z70zz__threadz00, BUNSPEC, -2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2lockz12zd2envz12zz__threadz00,
		BgL_bgl__mutexza7d2lockza7122515z00, opt_generic_entry,
		BGl__mutexzd2lockz12zc0zz__threadz00, BFALSE, -1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2271z00zz__threadz00,
		BgL_bgl_za762tbza7d2condvarza72516za7,
		BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2353z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2517z00,
		BGl_z62threadzd2startzd2joinabl1235z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2273z00zz__threadz00,
		BgL_bgl_za762threadza7d2init2518z00,
		BGl_z62threadzd2initializa7ez121195z05zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2360z00zz__threadz00,
		BgL_bgl_string2360za700za7za7_2519za7, "thread-kill!", 12);
	      DEFINE_STRING(BGl_string2280z00zz__threadz00,
		BgL_bgl_string2280za700za7za7_2520za7, "thread-join!1202", 16);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2355z00zz__threadz00,
		BgL_bgl_za762threadza7d2join2521z00, va_generic_entry,
		BGl_z62threadzd2joinz12zd2nothrea1237z70zz__threadz00, BUNSPEC, -2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2194z00zz__threadz00,
		BgL_bgl_za762lambda1370za7622522z00, BGl_z62lambda1370z62zz__threadz00, 0L,
		BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2275z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2523z00, va_generic_entry,
		BGl_z62threadzd2startz121198za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_STRING(BGl_string2362z00zz__threadz00,
		BgL_bgl_string2362za700za7za7_2524za7, "thread-specific", 15);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2195z00zz__threadz00,
		BgL_bgl_za762lambda1369za7622525z00, BGl_z62lambda1369z62zz__threadz00, 0L,
		BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2282z00zz__threadz00,
		BgL_bgl_string2282za700za7za7_2526za7, "thread-terminate!1204", 21);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2357z00zz__threadz00,
		BgL_bgl_za762threadza7d2term2527z00,
		BGl_z62threadzd2terminatez12zd2no1239z70zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2277z00zz__threadz00,
		BgL_bgl_za762threadza7d2star2528z00,
		BGl_z62threadzd2startzd2joinabl1200z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2364z00zz__threadz00,
		BgL_bgl_string2364za700za7za7_2529za7, "thread-specific-set!", 20);
	      DEFINE_STRING(BGl_string2284z00zz__threadz00,
		BgL_bgl_string2284za700za7za7_2530za7, "thread-kill!1206", 16);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2359z00zz__threadz00,
		BgL_bgl_za762threadza7d2kill2531z00,
		BGl_z62threadzd2killz12zd2nothrea1241z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_withzd2lockzd2envz00zz__threadz00,
		BgL_bgl_za762withza7d2lockza7b2532za7, BGl_z62withzd2lockzb0zz__threadz00,
		0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2279z00zz__threadz00,
		BgL_bgl_za762threadza7d2join2533z00, va_generic_entry,
		BGl_z62threadzd2joinz121202za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_STRING(BGl_string2366z00zz__threadz00,
		BgL_bgl_string2366za700za7za7_2534za7, "thread-cleanup", 14);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2199z00zz__threadz00,
		BgL_bgl_za762za7c3za704anonymo2535za7,
		BGl_z62zc3z04anonymousza31365ze3ze5zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2286z00zz__threadz00,
		BgL_bgl_string2286za700za7za7_2536za7, "thread-specific1208", 19);
	      DEFINE_STRING(BGl_string2368z00zz__threadz00,
		BgL_bgl_string2368za700za7za7_2537za7, "thread-cleanup-set!", 19);
	      DEFINE_STRING(BGl_string2288z00zz__threadz00,
		BgL_bgl_string2288za700za7za7_2538za7, "thread-specific-set!1210", 24);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2namezd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2nameza72539za7, BGl_z62mutexzd2namezb0zz__threadz00,
		0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2361z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2540z00,
		BGl_z62threadzd2specificzd2noth1243z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2281z00zz__threadz00,
		BgL_bgl_za762threadza7d2term2541z00,
		BGl_z62threadzd2terminatez121204za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2363z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2542z00,
		BGl_z62threadzd2specificzd2setz121245z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2370z00zz__threadz00,
		BgL_bgl_string2370za700za7za7_2543za7, "thread-name", 11);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2unlockz12zd2envz12zz__threadz00,
		BgL_bgl_za762mutexza7d2unloc2544z00,
		BGl_z62mutexzd2unlockz12za2zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2283z00zz__threadz00,
		BgL_bgl_za762threadza7d2kill2545z00,
		BGl_z62threadzd2killz121206za2zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2290z00zz__threadz00,
		BgL_bgl_string2290za700za7za7_2546za7, "thread-cleanup1213", 18);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2365z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2547z00,
		BGl_z62threadzd2cleanupzd2nothr1247z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2372z00zz__threadz00,
		BgL_bgl_string2372za700za7za7_2548za7, "thread-name-set!", 16);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2285z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2549z00,
		BGl_z62threadzd2specific1208zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2373z00zz__threadz00,
		BgL_bgl_string2373za700za7za7_2550za7, ">", 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2367z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2551z00,
		BGl_z62threadzd2cleanupzd2setz12zd21249za2zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2292z00zz__threadz00,
		BgL_bgl_string2292za700za7za7_2552za7, "thread-cleanup-set!1215", 23);
	      DEFINE_STRING(BGl_string2374z00zz__threadz00,
		BgL_bgl_string2374za700za7za7_2553za7, ":", 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2287z00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2554z00,
		BGl_z62threadzd2specificzd2setz121210z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STRING(BGl_string2375z00zz__threadz00,
		BgL_bgl_string2375za700za7za7_2555za7, "#<", 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2369z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2556z00,
		BGl_z62threadzd2namezd2nothread1251z62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2294z00zz__threadz00,
		BgL_bgl_string2294za700za7za7_2557za7, "thread-name1217", 15);
	extern obj_t BGl_conszd2envzd2zz__r4_pairs_and_lists_6_3z00;
	   
		 
		DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2289z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2558z00,
		BGl_z62threadzd2cleanup1213zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STRING(BGl_string2296z00zz__threadz00,
		BgL_bgl_string2296za700za7za7_2559za7, "thread-name-set!1219", 20);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2joinz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2join2560z00, va_generic_entry,
		BGl_z62threadzd2joinz12za2zz__threadz00, BUNSPEC, -2);
	      DEFINE_STRING(BGl_string2298z00zz__threadz00,
		BgL_bgl_string2298za700za7za7_2561za7, "%user-current-thread1226", 24);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2yieldz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2yiel2562z00,
		BGl_z62threadzd2yieldz12za2zz__threadz00, 0L, BUNSPEC, 0);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2371z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2563z00,
		BGl_z62threadzd2namezd2setz12zd2not1253za2zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
		BgL_bgl_za762tbza7d2currentza72564za7,
		BGl_z62tbzd2currentzd2threadz62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2291z00zz__threadz00,
		BgL_bgl_za762threadza7d2clea2565z00,
		BGl_z62threadzd2cleanupzd2setz121215z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2293z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2566z00,
		BGl_z62threadzd2name1217zb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2295z00zz__threadz00,
		BgL_bgl_za762threadza7d2name2567z00,
		BGl_z62threadzd2namezd2setz121219z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2297z00zz__threadz00,
		BgL_bgl_za762za752userza7d2cur2568za7,
		BGl_z62z52userzd2currentzd2thread1226z30zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_STATIC_BGL_PROCEDURE(BGl_proc2299z00zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2569za7,
		BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_threadzd2parameterzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2para2570z00,
		BGl_z62threadzd2parameterzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_PROCEDURE(BGl_withzd2timedzd2lockzd2envzd2zz__threadz00,
		BgL_bgl_za762withza7d2timedza72571za7,
		BGl_z62withzd2timedzd2lockz62zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2specificzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2spec2572z00,
		BGl_z62threadzd2specificzb0zz__threadz00, 0L, BUNSPEC, 1);
	extern obj_t BGl_objectzd2printzd2envz00zz__objectz00;
	extern obj_t BGl_objectzd2displayzd2envz00zz__objectz00;
	   
		 
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2star2573z00,
		BGl_z62threadzd2startzd2joinablez12z70zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2broadcastz12zd2envzc0zz__threadz00,
		BgL_bgl_za762conditionza7d2v2574z00,
		BGl_z62conditionzd2variablezd2broadcastz12z70zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_defaultzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762defaultza7d2thr2575z00,
		BGl_z62defaultzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2576za7,
		BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2killz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2kill2577z00,
		BGl_z62threadzd2killz12za2zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_makezd2conditionzd2variablezd2envzd2zz__threadz00,
		BgL_bgl__makeza7d2conditio2578za7, opt_generic_entry,
		BGl__makezd2conditionzd2variablez00zz__threadz00, BFALSE, -1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_dynamiczd2envzf3zd2envzf3zz__threadz00,
		BgL_bgl_za762dynamicza7d2env2579z00,
		BGl_z62dynamiczd2envzf3z43zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2signalz12zd2envzc0zz__threadz00,
		BgL_bgl_za762conditionza7d2v2580z00,
		BGl_z62conditionzd2variablezd2signalz12z70zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_GENERIC(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
		BgL_bgl_za762tbza7d2makeza7d2t2581za7,
		BGl_z62tbzd2makezd2threadz62zz__threadz00, 0L, BUNSPEC, 3);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_currentzd2threadzd2envz00zz__threadz00,
		BgL_bgl_za762currentza7d2thr2582z00,
		BGl_z62currentzd2threadzb0zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2namezd2envzd2zz__threadz00,
		BgL_bgl_za762conditionza7d2v2583z00,
		BGl_z62conditionzd2variablezd2namez62zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzf3zd2envz21zz__threadz00,
		BgL_bgl_za762mutexza7f3za791za7za72584za7, BGl_z62mutexzf3z91zz__threadz00,
		0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2parameterzd2envz00zz__threadz00,
		BgL_bgl_za762threadza7d2para2585z00,
		BGl_z62threadzd2parameterzb0zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2nilzd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2nilza7b2586za7, BGl_z62mutexzd2nilzb0zz__threadz00,
		0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
		BgL_bgl_za762za752userza7d2cur2587za7,
		BGl_z62z52userzd2currentzd2threadz30zz__threadz00, 0L, BUNSPEC, 1);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_mutexzd2statezd2envz00zz__threadz00,
		BgL_bgl_za762mutexza7d2state2588z00, BGl_z62mutexzd2statezb0zz__threadz00,
		0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
		BgL_bgl_za762threadza7d2init2589z00,
		BGl_z62threadzd2initializa7ez12z05zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762currentza7d2thr2590z00,
		BGl_z62currentzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_conditionzd2variablezd2nilzd2envzd2zz__threadz00,
		BgL_bgl_za762conditionza7d2v2591z00,
		BGl_z62conditionzd2variablezd2nilz62zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_currentzd2dynamiczd2envzd2envzd2zz__threadz00,
		BgL_bgl_za762currentza7d2dyn2592z00,
		BGl_z62currentzd2dynamiczd2envz62zz__threadz00, 0L, BUNSPEC, 0);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2term2593z00,
		BGl_z62threadzd2terminatez12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2name2594z00,
		BGl_z62threadzd2namezd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_makezd2mutexzd2envz00zz__threadz00,
		BgL_bgl__makeza7d2mutexza7d22595z00, opt_generic_entry,
		BGl__makezd2mutexzd2zz__threadz00, BFALSE, -1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
		BgL_bgl_za762za752userza7d2thr2596za7,
		BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
		BgL_bgl_za762tbza7d2mutexza7d22597za7,
		BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2spec2598z00,
		BGl_z62threadzd2specificzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
		BgL_bgl_za762threadza7d2clea2599z00,
		BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00, 0L, BUNSPEC, 2);
	      DEFINE_EXPORT_BGL_PROCEDURE(BGl_threadzd2sleepz12zd2envz12zz__threadz00,
		BgL_bgl_za762threadza7d2slee2600z00,
		BGl_z62threadzd2sleepz12za2zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_PROCEDURE
		(BGl_getzd2threadzd2backendzd2envzd2zz__threadz00,
		BgL_bgl_za762getza7d2threadza72601za7,
		BGl_z62getzd2threadzd2backendz62zz__threadz00, 0L, BUNSPEC, 1);
	     
		DEFINE_EXPORT_BGL_GENERIC
		(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
		BgL_bgl_za762tbza7d2condvarza72602za7,
		BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00, 0L, BUNSPEC, 2);

/* 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_nothreadzd2backendzd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_za2nothreadzd2backendza2zd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_nothreadz00zz__threadz00));
		   
			 ADD_ROOT((void
				*) (&BGl_za2conditionzd2variablezd2nilza2z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_threadzd2backendzd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_za2threadzd2backendsza2zd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2202z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2203z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2208z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2212z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2216z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2303z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2306z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2226z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2308z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2228z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2309z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2310z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2311z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2312z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2232z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2313z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2314z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2315z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2316z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2317z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2237z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2318z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2319z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2320z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2321z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2242z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2247z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2169z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2252z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2176z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2257z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2178z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2261z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2187z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2196z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_symbol2198z00zz__threadz00));
		     ADD_ROOT((void *) (&BGl_za2nothreadzd2currentza2zd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_za2mutexzd2nilza2zd2zz__threadz00));
		     ADD_ROOT((void *) (&BGl_threadz00zz__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_4855, char *BgL_fromz00_4856)
	{
		{
			if (CBOOL(BGl_requirezd2initializa7ationz75zz__threadz00))
				{
					BGl_requirezd2initializa7ationz75zz__threadz00 = BBOOL(((bool_t) 0));
					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_symbol2169z00zz__threadz00 =
				bstring_to_symbol(BGl_string2170z00zz__threadz00);
			BGl_symbol2176z00zz__threadz00 =
				bstring_to_symbol(BGl_string2177z00zz__threadz00);
			BGl_symbol2178z00zz__threadz00 =
				bstring_to_symbol(BGl_string2179z00zz__threadz00);
			BGl_symbol2187z00zz__threadz00 =
				bstring_to_symbol(BGl_string2188z00zz__threadz00);
			BGl_symbol2196z00zz__threadz00 =
				bstring_to_symbol(BGl_string2197z00zz__threadz00);
			BGl_symbol2198z00zz__threadz00 =
				bstring_to_symbol(BGl_string2168z00zz__threadz00);
			BGl_symbol2202z00zz__threadz00 =
				bstring_to_symbol(BGl_string2165z00zz__threadz00);
			BGl_symbol2203z00zz__threadz00 =
				bstring_to_symbol(BGl_string2204z00zz__threadz00);
			BGl_symbol2208z00zz__threadz00 =
				bstring_to_symbol(BGl_string2209z00zz__threadz00);
			BGl_symbol2212z00zz__threadz00 =
				bstring_to_symbol(BGl_string2213z00zz__threadz00);
			BGl_symbol2216z00zz__threadz00 =
				bstring_to_symbol(BGl_string2217z00zz__threadz00);
			BGl_symbol2226z00zz__threadz00 =
				bstring_to_symbol(BGl_string2227z00zz__threadz00);
			BGl_symbol2228z00zz__threadz00 =
				bstring_to_symbol(BGl_string2172z00zz__threadz00);
			BGl_symbol2232z00zz__threadz00 =
				bstring_to_symbol(BGl_string2233z00zz__threadz00);
			BGl_symbol2237z00zz__threadz00 =
				bstring_to_symbol(BGl_string2238z00zz__threadz00);
			BGl_symbol2242z00zz__threadz00 =
				bstring_to_symbol(BGl_string2243z00zz__threadz00);
			BGl_symbol2247z00zz__threadz00 =
				bstring_to_symbol(BGl_string2248z00zz__threadz00);
			BGl_symbol2252z00zz__threadz00 =
				bstring_to_symbol(BGl_string2253z00zz__threadz00);
			BGl_symbol2257z00zz__threadz00 =
				bstring_to_symbol(BGl_string2162z00zz__threadz00);
			BGl_symbol2261z00zz__threadz00 =
				bstring_to_symbol(BGl_string2262z00zz__threadz00);
			BGl_symbol2303z00zz__threadz00 =
				bstring_to_symbol(BGl_string2304z00zz__threadz00);
			BGl_symbol2306z00zz__threadz00 =
				bstring_to_symbol(BGl_string2296z00zz__threadz00);
			BGl_symbol2308z00zz__threadz00 =
				bstring_to_symbol(BGl_string2294z00zz__threadz00);
			BGl_symbol2309z00zz__threadz00 =
				bstring_to_symbol(BGl_string2292z00zz__threadz00);
			BGl_symbol2310z00zz__threadz00 =
				bstring_to_symbol(BGl_string2290z00zz__threadz00);
			BGl_symbol2311z00zz__threadz00 =
				bstring_to_symbol(BGl_string2288z00zz__threadz00);
			BGl_symbol2312z00zz__threadz00 =
				bstring_to_symbol(BGl_string2286z00zz__threadz00);
			BGl_symbol2313z00zz__threadz00 =
				bstring_to_symbol(BGl_string2284z00zz__threadz00);
			BGl_symbol2314z00zz__threadz00 =
				bstring_to_symbol(BGl_string2282z00zz__threadz00);
			BGl_symbol2315z00zz__threadz00 =
				bstring_to_symbol(BGl_string2280z00zz__threadz00);
			BGl_symbol2316z00zz__threadz00 =
				bstring_to_symbol(BGl_string2278z00zz__threadz00);
			BGl_symbol2317z00zz__threadz00 =
				bstring_to_symbol(BGl_string2276z00zz__threadz00);
			BGl_symbol2318z00zz__threadz00 =
				bstring_to_symbol(BGl_string2272z00zz__threadz00);
			BGl_symbol2319z00zz__threadz00 =
				bstring_to_symbol(BGl_string2270z00zz__threadz00);
			BGl_symbol2320z00zz__threadz00 =
				bstring_to_symbol(BGl_string2268z00zz__threadz00);
			return (BGl_symbol2321z00zz__threadz00 =
				bstring_to_symbol(BGl_string2266z00zz__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_1221;

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

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

						BgL_arg1322z00_1223 =
							BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1057z00_1222), BgL_arg1322z00_1223);
					}
					BgL_new1058z00_1221 = BgL_new1057z00_1222;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1058z00_1221)))->
						BgL_namez00) = ((obj_t) BGl_string2162z00zz__threadz00), BUNSPEC);
				BGl_za2nothreadzd2backendza2zd2zz__threadz00 = BgL_new1058z00_1221;
			}
			{	/* Llib/thread.scm 279 */
				obj_t BgL_list1323z00_1224;

				BgL_list1323z00_1224 =
					MAKE_YOUNG_PAIR(
					((obj_t) BGl_za2nothreadzd2backendza2zd2zz__threadz00), BNIL);
				BGl_za2threadzd2backendsza2zd2zz__threadz00 = BgL_list1323z00_1224;
			}
			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_3429,
		obj_t BgL_objz00_3430)
	{
		{	/* Llib/thread.scm 259 */
			return BBOOL(BGl_dynamiczd2envzf3z21zz__threadz00(BgL_objz00_3430));
		}

	}



/* 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_3431)
	{
		{	/* 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_3432)
	{
		{	/* 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_4921;

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

	}



/* &current-thread-backend-set! */
	obj_t BGl_z62currentzd2threadzd2backendzd2setz12za2zz__threadz00(obj_t
		BgL_envz00_3433, obj_t BgL_tbz00_3434)
	{
		{	/* Llib/thread.scm 290 */
			{	/* Llib/thread.scm 291 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_4925;

				if (BGl_isazf3zf3zz__objectz00(BgL_tbz00_3434,
						BGl_threadzd2backendzd2zz__threadz00))
					{	/* Llib/thread.scm 291 */
						BgL_auxz00_4925 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3434);
					}
				else
					{
						obj_t BgL_auxz00_4929;

						BgL_auxz00_4929 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(11215L), BGl_string2164z00zz__threadz00,
							BGl_string2165z00zz__threadz00, BgL_tbz00_3434);
						FAILURE(BgL_auxz00_4929, BFALSE, BFALSE);
					}
				return
					BGl_currentzd2threadzd2backendzd2setz12zc0zz__threadz00
					(BgL_auxz00_4925);
			}
		}

	}



/* 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_3435)
	{
		{	/* 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_3436, obj_t BgL_tbz00_3437)
	{
		{	/* Llib/thread.scm 303 */
			{	/* Llib/thread.scm 304 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_4940;

				if (BGl_isazf3zf3zz__objectz00(BgL_tbz00_3437,
						BGl_threadzd2backendzd2zz__threadz00))
					{	/* Llib/thread.scm 304 */
						BgL_auxz00_4940 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3437);
					}
				else
					{
						obj_t BgL_auxz00_4944;

						BgL_auxz00_4944 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(11833L), BGl_string2166z00zz__threadz00,
							BGl_string2165z00zz__threadz00, BgL_tbz00_3437);
						FAILURE(BgL_auxz00_4944, BFALSE, BFALSE);
					}
				return
					BGl_defaultzd2threadzd2backendzd2setz12zc0zz__threadz00
					(BgL_auxz00_4940);
			}
		}

	}



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

				BgL_tbsz00_1234 = BGl_za2threadzd2backendsza2zd2zz__threadz00;
			BgL_zc3z04anonymousza31328ze3z87_1235:
				if (PAIRP(BgL_tbsz00_1234))
					{	/* Llib/thread.scm 313 */
						BgL_threadzd2backendzd2_bglt BgL_i1059z00_1237;

						BgL_i1059z00_1237 =
							((BgL_threadzd2backendzd2_bglt) CAR(BgL_tbsz00_1234));
						{	/* Llib/thread.scm 314 */
							bool_t BgL_test2607z00_4953;

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

								BgL_arg1333z00_1241 =
									(((BgL_threadzd2backendzd2_bglt) COBJECT(BgL_i1059z00_1237))->
									BgL_namez00);
								{	/* Llib/thread.scm 314 */
									long BgL_l1z00_2216;

									BgL_l1z00_2216 = STRING_LENGTH(BgL_arg1333z00_1241);
									if ((BgL_l1z00_2216 == STRING_LENGTH(BgL_namez00_6)))
										{	/* Llib/thread.scm 314 */
											int BgL_arg1639z00_2219;

											{	/* Llib/thread.scm 314 */
												char *BgL_auxz00_4961;
												char *BgL_tmpz00_4959;

												BgL_auxz00_4961 = BSTRING_TO_STRING(BgL_namez00_6);
												BgL_tmpz00_4959 =
													BSTRING_TO_STRING(BgL_arg1333z00_1241);
												BgL_arg1639z00_2219 =
													memcmp(BgL_tmpz00_4959, BgL_auxz00_4961,
													BgL_l1z00_2216);
											}
											BgL_test2607z00_4953 =
												((long) (BgL_arg1639z00_2219) == 0L);
										}
									else
										{	/* Llib/thread.scm 314 */
											BgL_test2607z00_4953 = ((bool_t) 0);
										}
								}
							}
							if (BgL_test2607z00_4953)
								{	/* Llib/thread.scm 314 */
									return CAR(BgL_tbsz00_1234);
								}
							else
								{
									obj_t BgL_tbsz00_4967;

									BgL_tbsz00_4967 = CDR(BgL_tbsz00_1234);
									BgL_tbsz00_1234 = BgL_tbsz00_4967;
									goto BgL_zc3z04anonymousza31328ze3z87_1235;
								}
						}
					}
				else
					{	/* Llib/thread.scm 312 */
						return BFALSE;
					}
			}
		}

	}



/* &get-thread-backend */
	obj_t BGl_z62getzd2threadzd2backendz62zz__threadz00(obj_t BgL_envz00_3438,
		obj_t BgL_namez00_3439)
	{
		{	/* Llib/thread.scm 310 */
			{	/* Llib/thread.scm 312 */
				obj_t BgL_auxz00_4969;

				if (STRINGP(BgL_namez00_3439))
					{	/* Llib/thread.scm 312 */
						BgL_auxz00_4969 = BgL_namez00_3439;
					}
				else
					{
						obj_t BgL_auxz00_4972;

						BgL_auxz00_4972 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(12194L), BGl_string2167z00zz__threadz00,
							BGl_string2168z00zz__threadz00, BgL_namez00_3439);
						FAILURE(BgL_auxz00_4972, BFALSE, BFALSE);
					}
				return BGl_getzd2threadzd2backendz00zz__threadz00(BgL_auxz00_4969);
			}
		}

	}



/* _make-thread */
	obj_t BGl__makezd2threadzd2zz__threadz00(obj_t BgL_env1222z00_47,
		obj_t BgL_opt1221z00_46)
	{
		{	/* Llib/thread.scm 445 */
			{	/* Llib/thread.scm 445 */
				obj_t BgL_g1223z00_3956;

				BgL_g1223z00_3956 = VECTOR_REF(BgL_opt1221z00_46, 0L);
				switch (VECTOR_LENGTH(BgL_opt1221z00_46))
					{
					case 1L:

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

							BgL_namez00_3957 =
								BGl_gensymz00zz__r4_symbols_6_4z00
								(BGl_symbol2169z00zz__threadz00);
							{	/* Llib/thread.scm 445 */

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

									if (PROCEDUREP(BgL_g1223z00_3956))
										{	/* Llib/thread.scm 445 */
											BgL_bodyz00_3958 = BgL_g1223z00_3956;
										}
									else
										{
											obj_t BgL_auxz00_4981;

											BgL_auxz00_4981 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2163z00zz__threadz00, BINT(19158L),
												BGl_string2171z00zz__threadz00,
												BGl_string2172z00zz__threadz00, BgL_g1223z00_3956);
											FAILURE(BgL_auxz00_4981, BFALSE, BFALSE);
										}
									{	/* Llib/thread.scm 446 */
										obj_t BgL_arg1334z00_3959;

										BgL_arg1334z00_3959 =
											BGl_defaultzd2threadzd2backendz00zz__threadz00();
										{
											BgL_threadz00_bglt BgL_auxz00_4986;

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

												if (BGl_isazf3zf3zz__objectz00(BgL_arg1334z00_3959,
														BGl_threadzd2backendzd2zz__threadz00))
													{	/* Llib/thread.scm 446 */
														BgL_auxz00_4987 =
															((BgL_threadzd2backendzd2_bglt)
															BgL_arg1334z00_3959);
													}
												else
													{
														obj_t BgL_auxz00_4991;

														BgL_auxz00_4991 =
															BGl_typezd2errorzd2zz__errorz00
															(BGl_string2163z00zz__threadz00, BINT(19269L),
															BGl_string2171z00zz__threadz00,
															BGl_string2165z00zz__threadz00,
															BgL_arg1334z00_3959);
														FAILURE(BgL_auxz00_4991, BFALSE, BFALSE);
													}
												BgL_auxz00_4986 =
													BGl_tbzd2makezd2threadz00zz__threadz00
													(BgL_auxz00_4987, BgL_bodyz00_3958, BgL_namez00_3957);
											}
											return ((obj_t) BgL_auxz00_4986);
										}
									}
								}
							}
						}
						break;
					case 2L:

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

							BgL_namez00_3960 = VECTOR_REF(BgL_opt1221z00_46, 1L);
							{	/* Llib/thread.scm 445 */

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

									if (PROCEDUREP(BgL_g1223z00_3956))
										{	/* Llib/thread.scm 445 */
											BgL_bodyz00_3961 = BgL_g1223z00_3956;
										}
									else
										{
											obj_t BgL_auxz00_5000;

											BgL_auxz00_5000 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2163z00zz__threadz00, BINT(19158L),
												BGl_string2171z00zz__threadz00,
												BGl_string2172z00zz__threadz00, BgL_g1223z00_3956);
											FAILURE(BgL_auxz00_5000, BFALSE, BFALSE);
										}
									{	/* Llib/thread.scm 446 */
										obj_t BgL_arg1334z00_3962;

										BgL_arg1334z00_3962 =
											BGl_defaultzd2threadzd2backendz00zz__threadz00();
										{
											BgL_threadz00_bglt BgL_auxz00_5005;

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

												if (BGl_isazf3zf3zz__objectz00(BgL_arg1334z00_3962,
														BGl_threadzd2backendzd2zz__threadz00))
													{	/* Llib/thread.scm 446 */
														BgL_auxz00_5006 =
															((BgL_threadzd2backendzd2_bglt)
															BgL_arg1334z00_3962);
													}
												else
													{
														obj_t BgL_auxz00_5010;

														BgL_auxz00_5010 =
															BGl_typezd2errorzd2zz__errorz00
															(BGl_string2163z00zz__threadz00, BINT(19269L),
															BGl_string2171z00zz__threadz00,
															BGl_string2165z00zz__threadz00,
															BgL_arg1334z00_3962);
														FAILURE(BgL_auxz00_5010, BFALSE, BFALSE);
													}
												BgL_auxz00_5005 =
													BGl_tbzd2makezd2threadz00zz__threadz00
													(BgL_auxz00_5006, BgL_bodyz00_3961, BgL_namez00_3960);
											}
											return ((obj_t) BgL_auxz00_5005);
										}
									}
								}
							}
						}
						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_arg1334z00_3963;

				BgL_arg1334z00_3963 = BGl_defaultzd2threadzd2backendz00zz__threadz00();
				return
					BGl_tbzd2makezd2threadz00zz__threadz00(
					((BgL_threadzd2backendzd2_bglt) BgL_arg1334z00_3963), 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_1249;

				BgL_tbz00_1249 = BGL_THREAD_BACKEND();
				{	/* Llib/thread.scm 459 */
					bool_t BgL_test2614z00_5022;

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

						BgL_classz00_2237 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_1249))
							{	/* Llib/thread.scm 459 */
								BgL_objectz00_bglt BgL_arg1930z00_2239;

								BgL_arg1930z00_2239 = (BgL_objectz00_bglt) (BgL_tbz00_1249);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 459 */
										long BgL_idxz00_2245;

										BgL_idxz00_2245 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1930z00_2239);
										BgL_test2614z00_5022 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_2245 + 1L)) == BgL_classz00_2237);
									}
								else
									{	/* Llib/thread.scm 459 */
										bool_t BgL_res1943z00_2267;

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

											{	/* Llib/thread.scm 459 */
												long BgL_arg1938z00_2259;

												{	/* Llib/thread.scm 459 */
													long BgL_arg1939z00_2260;

													BgL_arg1939z00_2260 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1930z00_2239);
													BgL_arg1938z00_2259 =
														(BgL_arg1939z00_2260 - OBJECT_TYPE);
												}
												BgL_oclassz00_2253 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_2259);
											}
											{	/* Llib/thread.scm 459 */
												bool_t BgL__ortest_1147z00_2254;

												BgL__ortest_1147z00_2254 =
													(BgL_classz00_2237 == BgL_oclassz00_2253);
												if (BgL__ortest_1147z00_2254)
													{	/* Llib/thread.scm 459 */
														BgL_res1943z00_2267 = BgL__ortest_1147z00_2254;
													}
												else
													{	/* Llib/thread.scm 459 */
														long BgL_odepthz00_2255;

														BgL_odepthz00_2255 =
															BGL_CLASS_DEPTH(BgL_oclassz00_2253);
														if ((1L < BgL_odepthz00_2255))
															{	/* Llib/thread.scm 459 */
																obj_t BgL_arg1927z00_2257;

																BgL_arg1927z00_2257 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_2253,
																	1L);
																BgL_res1943z00_2267 =
																	(BgL_arg1927z00_2257 == BgL_classz00_2237);
															}
														else
															{	/* Llib/thread.scm 459 */
																BgL_res1943z00_2267 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2614z00_5022 = BgL_res1943z00_2267;
									}
							}
						else
							{	/* Llib/thread.scm 459 */
								BgL_test2614z00_5022 = ((bool_t) 0);
							}
					}
					if (BgL_test2614z00_5022)
						{	/* Llib/thread.scm 459 */
							return
								BGl_tbzd2currentzd2threadz00zz__threadz00(
								((BgL_threadzd2backendzd2_bglt) BgL_tbz00_1249));
						}
					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_1251;

				BgL_thz00_1251 = BGl_z52currentzd2threadz80zz__threadz00();
				{	/* Llib/thread.scm 467 */
					bool_t BgL_test2619z00_5045;

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

						BgL_classz00_2268 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_1251))
							{	/* Llib/thread.scm 467 */
								BgL_objectz00_bglt BgL_arg1930z00_2270;

								BgL_arg1930z00_2270 = (BgL_objectz00_bglt) (BgL_thz00_1251);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 467 */
										long BgL_idxz00_2276;

										BgL_idxz00_2276 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1930z00_2270);
										BgL_test2619z00_5045 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_2276 + 1L)) == BgL_classz00_2268);
									}
								else
									{	/* Llib/thread.scm 467 */
										bool_t BgL_res1944z00_2298;

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

											{	/* Llib/thread.scm 467 */
												long BgL_arg1938z00_2290;

												{	/* Llib/thread.scm 467 */
													long BgL_arg1939z00_2291;

													BgL_arg1939z00_2291 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1930z00_2270);
													BgL_arg1938z00_2290 =
														(BgL_arg1939z00_2291 - OBJECT_TYPE);
												}
												BgL_oclassz00_2284 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_2290);
											}
											{	/* Llib/thread.scm 467 */
												bool_t BgL__ortest_1147z00_2285;

												BgL__ortest_1147z00_2285 =
													(BgL_classz00_2268 == BgL_oclassz00_2284);
												if (BgL__ortest_1147z00_2285)
													{	/* Llib/thread.scm 467 */
														BgL_res1944z00_2298 = BgL__ortest_1147z00_2285;
													}
												else
													{	/* Llib/thread.scm 467 */
														long BgL_odepthz00_2286;

														BgL_odepthz00_2286 =
															BGL_CLASS_DEPTH(BgL_oclassz00_2284);
														if ((1L < BgL_odepthz00_2286))
															{	/* Llib/thread.scm 467 */
																obj_t BgL_arg1927z00_2288;

																BgL_arg1927z00_2288 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_2284,
																	1L);
																BgL_res1944z00_2298 =
																	(BgL_arg1927z00_2288 == BgL_classz00_2268);
															}
														else
															{	/* Llib/thread.scm 467 */
																BgL_res1944z00_2298 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2619z00_5045 = BgL_res1944z00_2298;
									}
							}
						else
							{	/* Llib/thread.scm 467 */
								BgL_test2619z00_5045 = ((bool_t) 0);
							}
					}
					if (BgL_test2619z00_5045)
						{	/* Llib/thread.scm 467 */
							return
								BGl_z52userzd2currentzd2threadz52zz__threadz00(
								((BgL_threadz00_bglt) BgL_thz00_1251));
						}
					else
						{	/* Llib/thread.scm 467 */
							return BFALSE;
						}
				}
			}
		}

	}



/* &current-thread */
	obj_t BGl_z62currentzd2threadzb0zz__threadz00(obj_t BgL_envz00_3440)
	{
		{	/* 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_arg1337z00_3964;

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

	}



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

	}



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

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

	}



/* &thread-yield! */
	obj_t BGl_z62threadzd2yieldz12za2zz__threadz00(obj_t BgL_envz00_3443)
	{
		{	/* 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_2301;

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

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

	}



/* &thread-parameter */
	obj_t BGl_z62threadzd2parameterzb0zz__threadz00(obj_t BgL_envz00_3444,
		obj_t BgL_idz00_3445)
	{
		{	/* Llib/thread.scm 512 */
			{	/* Llib/thread.scm 513 */
				obj_t BgL_auxz00_5081;

				if (SYMBOLP(BgL_idz00_3445))
					{	/* Llib/thread.scm 513 */
						BgL_auxz00_5081 = BgL_idz00_3445;
					}
				else
					{
						obj_t BgL_auxz00_5084;

						BgL_auxz00_5084 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(22199L), BGl_string2173z00zz__threadz00,
							BGl_string2174z00zz__threadz00, BgL_idz00_3445);
						FAILURE(BgL_auxz00_5084, BFALSE, BFALSE);
					}
				return BGl_threadzd2parameterzd2zz__threadz00(BgL_auxz00_5081);
			}
		}

	}



/* 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_2305;

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

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

							{	/* Llib/thread.scm 527 */
								obj_t BgL_arg1344z00_2309;
								obj_t BgL_arg1345z00_2310;

								BgL_arg1344z00_2309 =
									MAKE_YOUNG_PAIR(BgL_idz00_54, BgL_valz00_55);
								BgL_arg1345z00_2310 = BGL_PARAMETERS();
								BgL_arg1343z00_2308 =
									MAKE_YOUNG_PAIR(BgL_arg1344z00_2309, BgL_arg1345z00_2310);
							}
							BGL_PARAMETERS_SET(BgL_arg1343z00_2308);
						}
						return BgL_valz00_55;
					}
			}
		}

	}



/* &thread-parameter-set! */
	obj_t BGl_z62threadzd2parameterzd2setz12z70zz__threadz00(obj_t
		BgL_envz00_3446, obj_t BgL_idz00_3447, obj_t BgL_valz00_3448)
	{
		{	/* Llib/thread.scm 521 */
			{	/* Llib/thread.scm 522 */
				obj_t BgL_auxz00_5098;

				if (SYMBOLP(BgL_idz00_3447))
					{	/* Llib/thread.scm 522 */
						BgL_auxz00_5098 = BgL_idz00_3447;
					}
				else
					{
						obj_t BgL_auxz00_5101;

						BgL_auxz00_5101 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(22546L), BGl_string2175z00zz__threadz00,
							BGl_string2174z00zz__threadz00, BgL_idz00_3447);
						FAILURE(BgL_auxz00_5101, BFALSE, BFALSE);
					}
				return
					BGl_threadzd2parameterzd2setz12z12zz__threadz00(BgL_auxz00_5098,
					BgL_valz00_3448);
			}
		}

	}



/* 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_3449,
		obj_t BgL_objz00_3450)
	{
		{	/* Llib/thread.scm 614 */
			return BBOOL(BGl_mutexzf3zf3zz__threadz00(BgL_objz00_3450));
		}

	}



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

				switch (VECTOR_LENGTH(BgL_opt1254z00_75))
					{
					case 0L:

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

							BgL_namez00_3966 =
								BGl_gensymz00zz__r4_symbols_6_4z00
								(BGl_symbol2176z00zz__threadz00);
							{	/* Llib/thread.scm 620 */

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

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

							BgL_namez00_3967 = VECTOR_REF(BgL_opt1254z00_75, 0L);
							{	/* Llib/thread.scm 620 */

								return bgl_make_mutex(BgL_namez00_3967);
							}
						}
						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_env1259z00_79,
		obj_t BgL_opt1258z00_78)
	{
		{	/* Llib/thread.scm 626 */
			{	/* Llib/thread.scm 626 */

				switch (VECTOR_LENGTH(BgL_opt1258z00_78))
					{
					case 0L:

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

							BgL_namez00_3968 =
								BGl_gensymz00zz__r4_symbols_6_4z00
								(BGl_symbol2178z00zz__threadz00);
							{	/* Llib/thread.scm 626 */

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

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

							BgL_namez00_3969 = VECTOR_REF(BgL_opt1258z00_78, 0L);
							{	/* Llib/thread.scm 626 */

								return bgl_make_spinlock(BgL_namez00_3969);
							}
						}
						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_3451)
	{
		{	/* 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_3452,
		obj_t BgL_objz00_3453)
	{
		{	/* Llib/thread.scm 638 */
			{	/* Llib/thread.scm 639 */
				obj_t BgL_auxz00_5125;

				if (BGL_MUTEXP(BgL_objz00_3453))
					{	/* Llib/thread.scm 639 */
						BgL_auxz00_5125 = BgL_objz00_3453;
					}
				else
					{
						obj_t BgL_auxz00_5128;

						BgL_auxz00_5128 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(28093L), BGl_string2180z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_objz00_3453);
						FAILURE(BgL_auxz00_5128, BFALSE, BFALSE);
					}
				return BGl_mutexzd2namezd2zz__threadz00(BgL_auxz00_5125);
			}
		}

	}



/* _mutex-lock! */
	obj_t BGl__mutexzd2lockz12zc0zz__threadz00(obj_t BgL_env1263z00_84,
		obj_t BgL_opt1262z00_83)
	{
		{	/* Llib/thread.scm 644 */
			{	/* Llib/thread.scm 644 */
				obj_t BgL_g1264z00_3970;

				BgL_g1264z00_3970 = VECTOR_REF(BgL_opt1262z00_83, 0L);
				switch (VECTOR_LENGTH(BgL_opt1262z00_83))
					{
					case 1L:

						{	/* Llib/thread.scm 644 */

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

								if (BGL_MUTEXP(BgL_g1264z00_3970))
									{	/* Llib/thread.scm 644 */
										BgL_mz00_3971 = BgL_g1264z00_3970;
									}
								else
									{
										obj_t BgL_auxz00_5136;

										BgL_auxz00_5136 =
											BGl_typezd2errorzd2zz__errorz00
											(BGl_string2163z00zz__threadz00, BINT(28335L),
											BGl_string2181z00zz__threadz00,
											BGl_string2177z00zz__threadz00, BgL_g1264z00_3970);
										FAILURE(BgL_auxz00_5136, BFALSE, BFALSE);
									}
								{	/* Llib/thread.scm 646 */
									int BgL_arg1348z00_3972;

									BgL_arg1348z00_3972 = BGL_MUTEX_LOCK(BgL_mz00_3971);
									return BBOOL(((long) (BgL_arg1348z00_3972) == 0L));
						}}} break;
					case 2L:

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

							BgL_timeoutz00_3973 = VECTOR_REF(BgL_opt1262z00_83, 1L);
							{	/* Llib/thread.scm 644 */

								{	/* Llib/thread.scm 644 */
									obj_t BgL_mz00_3974;
									long BgL_timeoutz00_3975;

									if (BGL_MUTEXP(BgL_g1264z00_3970))
										{	/* Llib/thread.scm 644 */
											BgL_mz00_3974 = BgL_g1264z00_3970;
										}
									else
										{
											obj_t BgL_auxz00_5147;

											BgL_auxz00_5147 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2163z00zz__threadz00, BINT(28335L),
												BGl_string2181z00zz__threadz00,
												BGl_string2177z00zz__threadz00, BgL_g1264z00_3970);
											FAILURE(BgL_auxz00_5147, BFALSE, BFALSE);
										}
									{	/* Llib/thread.scm 644 */
										obj_t BgL_tmpz00_5151;

										if (INTEGERP(BgL_timeoutz00_3973))
											{	/* Llib/thread.scm 644 */
												BgL_tmpz00_5151 = BgL_timeoutz00_3973;
											}
										else
											{
												obj_t BgL_auxz00_5154;

												BgL_auxz00_5154 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2163z00zz__threadz00, BINT(28335L),
													BGl_string2181z00zz__threadz00,
													BGl_string2182z00zz__threadz00, BgL_timeoutz00_3973);
												FAILURE(BgL_auxz00_5154, BFALSE, BFALSE);
											}
										BgL_timeoutz00_3975 = (long) CINT(BgL_tmpz00_5151);
									}
									if ((BgL_timeoutz00_3975 == 0L))
										{	/* Llib/thread.scm 646 */
											int BgL_arg1348z00_3976;

											BgL_arg1348z00_3976 = BGL_MUTEX_LOCK(BgL_mz00_3974);
											return BBOOL(((long) (BgL_arg1348z00_3976) == 0L));
										}
									else
										{	/* Llib/thread.scm 647 */
											int BgL_arg1349z00_3977;

											BgL_arg1349z00_3977 =
												BGL_MUTEX_TIMED_LOCK(BgL_mz00_3974,
												BgL_timeoutz00_3975);
											return BBOOL(((long) (BgL_arg1349z00_3977) == 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_arg1348z00_3978;

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

					BgL_arg1349z00_3979 =
						BGL_MUTEX_TIMED_LOCK(BgL_mz00_81, BgL_timeoutz00_82);
					return BBOOL(((long) (BgL_arg1349z00_3979) == 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_arg1352z00_3980;

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

	}



/* &mutex-unlock! */
	obj_t BGl_z62mutexzd2unlockz12za2zz__threadz00(obj_t BgL_envz00_3454,
		obj_t BgL_mz00_3455)
	{
		{	/* Llib/thread.scm 652 */
			{	/* Llib/thread.scm 653 */
				obj_t BgL_auxz00_5185;

				if (BGL_MUTEXP(BgL_mz00_3455))
					{	/* Llib/thread.scm 653 */
						BgL_auxz00_5185 = BgL_mz00_3455;
					}
				else
					{
						obj_t BgL_auxz00_5188;

						BgL_auxz00_5188 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(28760L), BGl_string2183z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_mz00_3455);
						FAILURE(BgL_auxz00_5188, BFALSE, BFALSE);
					}
				return BGl_mutexzd2unlockz12zc0zz__threadz00(BgL_auxz00_5185);
			}
		}

	}



/* 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_3456,
		obj_t BgL_mutexz00_3457)
	{
		{	/* Llib/thread.scm 658 */
			{	/* Llib/thread.scm 659 */
				obj_t BgL_auxz00_5194;

				if (BGL_MUTEXP(BgL_mutexz00_3457))
					{	/* Llib/thread.scm 659 */
						BgL_auxz00_5194 = BgL_mutexz00_3457;
					}
				else
					{
						obj_t BgL_auxz00_5197;

						BgL_auxz00_5197 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(29043L), BGl_string2184z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_mutexz00_3457);
						FAILURE(BgL_auxz00_5197, BFALSE, BFALSE);
					}
				return BGl_mutexzd2statezd2zz__threadz00(BgL_auxz00_5194);
			}
		}

	}



/* 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_top2637z00_5203;

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

					BgL_tmp2636z00_5202 =
						(VA_PROCEDUREP(BgL_thunkz00_89) ? ((obj_t(*)(obj_t,
									...)) PROCEDURE_ENTRY(BgL_thunkz00_89)) (BgL_thunkz00_89,
							BEOA) : ((obj_t(*)(obj_t))
							PROCEDURE_ENTRY(BgL_thunkz00_89)) (BgL_thunkz00_89));
					BGL_EXITD_POP_PROTECT(BgL_top2637z00_5203);
					BUNSPEC;
					BGL_MUTEX_UNLOCK(BgL_mutexz00_88);
					return BgL_tmp2636z00_5202;
				}
			}
		}

	}



/* &with-lock */
	obj_t BGl_z62withzd2lockzb0zz__threadz00(obj_t BgL_envz00_3458,
		obj_t BgL_mutexz00_3459, obj_t BgL_thunkz00_3460)
	{
		{	/* Llib/thread.scm 670 */
			{	/* Llib/thread.scm 671 */
				obj_t BgL_auxz00_5219;
				obj_t BgL_auxz00_5212;

				if (PROCEDUREP(BgL_thunkz00_3460))
					{	/* Llib/thread.scm 671 */
						BgL_auxz00_5219 = BgL_thunkz00_3460;
					}
				else
					{
						obj_t BgL_auxz00_5222;

						BgL_auxz00_5222 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(29606L), BGl_string2185z00zz__threadz00,
							BGl_string2172z00zz__threadz00, BgL_thunkz00_3460);
						FAILURE(BgL_auxz00_5222, BFALSE, BFALSE);
					}
				if (BGL_MUTEXP(BgL_mutexz00_3459))
					{	/* Llib/thread.scm 671 */
						BgL_auxz00_5212 = BgL_mutexz00_3459;
					}
				else
					{
						obj_t BgL_auxz00_5215;

						BgL_auxz00_5215 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(29606L), BGl_string2185z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_mutexz00_3459);
						FAILURE(BgL_auxz00_5215, BFALSE, BFALSE);
					}
				return
					BGl_withzd2lockzd2zz__threadz00(BgL_auxz00_5212, BgL_auxz00_5219);
			}
		}

	}



/* 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_test2640z00_5227;

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

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

							BgL_arg1348z00_2356 = BGL_MUTEX_LOCK(BgL_mutexz00_90);
							BgL_test2640z00_5227 = ((long) (BgL_arg1348z00_2356) == 0L);
						}
					else
						{	/* Llib/thread.scm 647 */
							int BgL_arg1349z00_2357;

							BgL_arg1349z00_2357 =
								BGL_MUTEX_TIMED_LOCK(BgL_mutexz00_90, BgL_timeoutz00_2354);
							BgL_test2640z00_5227 = ((long) (BgL_arg1349z00_2357) == 0L);
				}}
				if (BgL_test2640z00_5227)
					{	/* Llib/thread.scm 679 */
						obj_t BgL_exitd1103z00_2350;

						BgL_exitd1103z00_2350 = BGL_EXITD_TOP_AS_OBJ();
						{	/* Llib/thread.scm 681 */
							obj_t BgL_zc3z04anonymousza31354ze3z87_3461;

							BgL_zc3z04anonymousza31354ze3z87_3461 =
								MAKE_FX_PROCEDURE
								(BGl_z62zc3z04anonymousza31354ze3ze5zz__threadz00, (int) (0L),
								(int) (1L));
							PROCEDURE_SET(BgL_zc3z04anonymousza31354ze3z87_3461, (int) (0L),
								BgL_mutexz00_90);
							{	/* Llib/thread.scm 679 */
								obj_t BgL_arg1921z00_2364;

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

									BgL_arg1922z00_2365 =
										BGL_EXITD_PROTECT(BgL_exitd1103z00_2350);
									BgL_arg1921z00_2364 =
										MAKE_YOUNG_PAIR(BgL_zc3z04anonymousza31354ze3z87_3461,
										BgL_arg1922z00_2365);
								}
								BGL_EXITD_PROTECT_SET(BgL_exitd1103z00_2350,
									BgL_arg1921z00_2364);
								BUNSPEC;
							}
							{	/* Llib/thread.scm 680 */
								obj_t BgL_tmp1105z00_2352;

								BgL_tmp1105z00_2352 =
									(VA_PROCEDUREP(BgL_thunkz00_92) ? ((obj_t(*)(obj_t,
												...))
										PROCEDURE_ENTRY(BgL_thunkz00_92)) (BgL_thunkz00_92,
										BEOA) : ((obj_t(*)(obj_t))
										PROCEDURE_ENTRY(BgL_thunkz00_92)) (BgL_thunkz00_92));
								{	/* Llib/thread.scm 679 */
									bool_t BgL_test2642z00_5249;

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

										BgL_arg1920z00_2367 =
											BGL_EXITD_PROTECT(BgL_exitd1103z00_2350);
										BgL_test2642z00_5249 = PAIRP(BgL_arg1920z00_2367);
									}
									if (BgL_test2642z00_5249)
										{	/* Llib/thread.scm 679 */
											obj_t BgL_arg1917z00_2368;

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

												BgL_arg1918z00_2369 =
													BGL_EXITD_PROTECT(BgL_exitd1103z00_2350);
												BgL_arg1917z00_2368 =
													CDR(((obj_t) BgL_arg1918z00_2369));
											}
											BGL_EXITD_PROTECT_SET(BgL_exitd1103z00_2350,
												BgL_arg1917z00_2368);
											BUNSPEC;
										}
									else
										{	/* Llib/thread.scm 679 */
											BFALSE;
										}
								}
								{	/* Llib/thread.scm 653 */
									int BgL_arg1352z00_2372;

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

	}



/* &with-timed-lock */
	obj_t BGl_z62withzd2timedzd2lockz62zz__threadz00(obj_t BgL_envz00_3462,
		obj_t BgL_mutexz00_3463, obj_t BgL_timeoutz00_3464, obj_t BgL_thunkz00_3465)
	{
		{	/* Llib/thread.scm 677 */
			{	/* Llib/thread.scm 678 */
				obj_t BgL_auxz00_5275;
				int BgL_auxz00_5266;
				obj_t BgL_auxz00_5259;

				if (PROCEDUREP(BgL_thunkz00_3465))
					{	/* Llib/thread.scm 678 */
						BgL_auxz00_5275 = BgL_thunkz00_3465;
					}
				else
					{
						obj_t BgL_auxz00_5278;

						BgL_auxz00_5278 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(29913L), BGl_string2186z00zz__threadz00,
							BGl_string2172z00zz__threadz00, BgL_thunkz00_3465);
						FAILURE(BgL_auxz00_5278, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 678 */
					obj_t BgL_tmpz00_5267;

					if (INTEGERP(BgL_timeoutz00_3464))
						{	/* Llib/thread.scm 678 */
							BgL_tmpz00_5267 = BgL_timeoutz00_3464;
						}
					else
						{
							obj_t BgL_auxz00_5270;

							BgL_auxz00_5270 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(29913L), BGl_string2186z00zz__threadz00,
								BGl_string2182z00zz__threadz00, BgL_timeoutz00_3464);
							FAILURE(BgL_auxz00_5270, BFALSE, BFALSE);
						}
					BgL_auxz00_5266 = CINT(BgL_tmpz00_5267);
				}
				if (BGL_MUTEXP(BgL_mutexz00_3463))
					{	/* Llib/thread.scm 678 */
						BgL_auxz00_5259 = BgL_mutexz00_3463;
					}
				else
					{
						obj_t BgL_auxz00_5262;

						BgL_auxz00_5262 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(29913L), BGl_string2186z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_mutexz00_3463);
						FAILURE(BgL_auxz00_5262, BFALSE, BFALSE);
					}
				return
					BGl_withzd2timedzd2lockz00zz__threadz00(BgL_auxz00_5259,
					BgL_auxz00_5266, BgL_auxz00_5275);
			}
		}

	}



/* &<@anonymous:1354> */
	obj_t BGl_z62zc3z04anonymousza31354ze3ze5zz__threadz00(obj_t BgL_envz00_3466)
	{
		{	/* Llib/thread.scm 679 */
			{	/* Llib/thread.scm 653 */
				obj_t BgL_mutexz00_3467;

				BgL_mutexz00_3467 =
					((obj_t) PROCEDURE_REF(BgL_envz00_3466, (int) (0L)));
				{	/* Llib/thread.scm 653 */
					bool_t BgL_tmpz00_5286;

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

						BgL_arg1352z00_3981 = BGL_MUTEX_UNLOCK(BgL_mutexz00_3467);
						BgL_tmpz00_5286 = ((long) (BgL_arg1352z00_3981) == 0L);
					}
					return BBOOL(BgL_tmpz00_5286);
				}
			}
		}

	}



/* 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_3468,
		obj_t BgL_objz00_3469)
	{
		{	/* Llib/thread.scm 686 */
			return
				BBOOL(BGl_conditionzd2variablezf3z21zz__threadz00(BgL_objz00_3469));
		}

	}



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

				switch (VECTOR_LENGTH(BgL_opt1267z00_95))
					{
					case 0L:

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

							BgL_namez00_3982 =
								BGl_gensymz00zz__r4_symbols_6_4z00
								(BGl_symbol2187z00zz__threadz00);
							{	/* Llib/thread.scm 692 */

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

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

							BgL_namez00_3983 = VECTOR_REF(BgL_opt1267z00_95, 0L);
							{	/* Llib/thread.scm 692 */

								return bgl_make_condvar(BgL_namez00_3983);
							}
						}
						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_3470)
	{
		{	/* 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_3471, obj_t BgL_objz00_3472)
	{
		{	/* Llib/thread.scm 705 */
			{	/* Llib/thread.scm 706 */
				obj_t BgL_auxz00_5303;

				if (BGL_CONDVARP(BgL_objz00_3472))
					{	/* Llib/thread.scm 706 */
						BgL_auxz00_5303 = BgL_objz00_3472;
					}
				else
					{
						obj_t BgL_auxz00_5306;

						BgL_auxz00_5306 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(31238L), BGl_string2189z00zz__threadz00,
							BGl_string2190z00zz__threadz00, BgL_objz00_3472);
						FAILURE(BgL_auxz00_5306, BFALSE, BFALSE);
					}
				return BGl_conditionzd2variablezd2namez00zz__threadz00(BgL_auxz00_5303);
			}
		}

	}



/* _condition-variable-wait! */
	obj_t BGl__conditionzd2variablezd2waitz12z12zz__threadz00(obj_t
		BgL_env1272z00_102, obj_t BgL_opt1271z00_101)
	{
		{	/* Llib/thread.scm 711 */
			{	/* Llib/thread.scm 711 */
				obj_t BgL_g1273z00_3984;
				obj_t BgL_g1274z00_3985;

				BgL_g1273z00_3984 = VECTOR_REF(BgL_opt1271z00_101, 0L);
				BgL_g1274z00_3985 = VECTOR_REF(BgL_opt1271z00_101, 1L);
				switch (VECTOR_LENGTH(BgL_opt1271z00_101))
					{
					case 2L:

						{	/* Llib/thread.scm 711 */

							{	/* Llib/thread.scm 711 */
								obj_t BgL_cz00_3986;
								obj_t BgL_mz00_3987;

								if (BGL_CONDVARP(BgL_g1273z00_3984))
									{	/* Llib/thread.scm 711 */
										BgL_cz00_3986 = BgL_g1273z00_3984;
									}
								else
									{
										obj_t BgL_auxz00_5315;

										BgL_auxz00_5315 =
											BGl_typezd2errorzd2zz__errorz00
											(BGl_string2163z00zz__threadz00, BINT(31482L),
											BGl_string2191z00zz__threadz00,
											BGl_string2190z00zz__threadz00, BgL_g1273z00_3984);
										FAILURE(BgL_auxz00_5315, BFALSE, BFALSE);
									}
								if (BGL_MUTEXP(BgL_g1274z00_3985))
									{	/* Llib/thread.scm 711 */
										BgL_mz00_3987 = BgL_g1274z00_3985;
									}
								else
									{
										obj_t BgL_auxz00_5321;

										BgL_auxz00_5321 =
											BGl_typezd2errorzd2zz__errorz00
											(BGl_string2163z00zz__threadz00, BINT(31482L),
											BGl_string2191z00zz__threadz00,
											BGl_string2177z00zz__threadz00, BgL_g1274z00_3985);
										FAILURE(BgL_auxz00_5321, BFALSE, BFALSE);
									}
								return BBOOL(BGL_CONDVAR_WAIT(BgL_cz00_3986, BgL_mz00_3987));
							}
						}
						break;
					case 3L:

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

							BgL_timeoutz00_3988 = VECTOR_REF(BgL_opt1271z00_101, 2L);
							{	/* Llib/thread.scm 711 */

								{	/* Llib/thread.scm 711 */
									obj_t BgL_cz00_3989;
									obj_t BgL_mz00_3990;
									long BgL_timeoutz00_3991;

									if (BGL_CONDVARP(BgL_g1273z00_3984))
										{	/* Llib/thread.scm 711 */
											BgL_cz00_3989 = BgL_g1273z00_3984;
										}
									else
										{
											obj_t BgL_auxz00_5330;

											BgL_auxz00_5330 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2163z00zz__threadz00, BINT(31482L),
												BGl_string2191z00zz__threadz00,
												BGl_string2190z00zz__threadz00, BgL_g1273z00_3984);
											FAILURE(BgL_auxz00_5330, BFALSE, BFALSE);
										}
									if (BGL_MUTEXP(BgL_g1274z00_3985))
										{	/* Llib/thread.scm 711 */
											BgL_mz00_3990 = BgL_g1274z00_3985;
										}
									else
										{
											obj_t BgL_auxz00_5336;

											BgL_auxz00_5336 =
												BGl_typezd2errorzd2zz__errorz00
												(BGl_string2163z00zz__threadz00, BINT(31482L),
												BGl_string2191z00zz__threadz00,
												BGl_string2177z00zz__threadz00, BgL_g1274z00_3985);
											FAILURE(BgL_auxz00_5336, BFALSE, BFALSE);
										}
									{	/* Llib/thread.scm 711 */
										obj_t BgL_tmpz00_5340;

										if (INTEGERP(BgL_timeoutz00_3988))
											{	/* Llib/thread.scm 711 */
												BgL_tmpz00_5340 = BgL_timeoutz00_3988;
											}
										else
											{
												obj_t BgL_auxz00_5343;

												BgL_auxz00_5343 =
													BGl_typezd2errorzd2zz__errorz00
													(BGl_string2163z00zz__threadz00, BINT(31482L),
													BGl_string2191z00zz__threadz00,
													BGl_string2182z00zz__threadz00, BgL_timeoutz00_3988);
												FAILURE(BgL_auxz00_5343, BFALSE, BFALSE);
											}
										BgL_timeoutz00_3991 = (long) CINT(BgL_tmpz00_5340);
									}
									if ((BgL_timeoutz00_3991 == 0L))
										{	/* Llib/thread.scm 712 */
											return
												BBOOL(BGL_CONDVAR_WAIT(BgL_cz00_3989, BgL_mz00_3990));
										}
									else
										{	/* Llib/thread.scm 712 */
											return
												BBOOL(BGL_CONDVAR_TIMED_WAIT(BgL_cz00_3989,
													BgL_mz00_3990, BgL_timeoutz00_3991));
										}
								}
							}
						}
						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_3473, obj_t BgL_cz00_3474)
	{
		{	/* Llib/thread.scm 719 */
			{	/* Llib/thread.scm 720 */
				bool_t BgL_tmpz00_5361;

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

					if (BGL_CONDVARP(BgL_cz00_3474))
						{	/* Llib/thread.scm 720 */
							BgL_auxz00_5362 = BgL_cz00_3474;
						}
					else
						{
							obj_t BgL_auxz00_5365;

							BgL_auxz00_5365 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(31924L), BGl_string2192z00zz__threadz00,
								BGl_string2190z00zz__threadz00, BgL_cz00_3474);
							FAILURE(BgL_auxz00_5365, BFALSE, BFALSE);
						}
					BgL_tmpz00_5361 =
						BGl_conditionzd2variablezd2signalz12z12zz__threadz00
						(BgL_auxz00_5362);
				}
				return BBOOL(BgL_tmpz00_5361);
			}
		}

	}



/* 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_3475, obj_t BgL_cz00_3476)
	{
		{	/* Llib/thread.scm 725 */
			{	/* Llib/thread.scm 726 */
				bool_t BgL_tmpz00_5372;

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

					if (BGL_CONDVARP(BgL_cz00_3476))
						{	/* Llib/thread.scm 726 */
							BgL_auxz00_5373 = BgL_cz00_3476;
						}
					else
						{
							obj_t BgL_auxz00_5376;

							BgL_auxz00_5376 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(32221L), BGl_string2193z00zz__threadz00,
								BGl_string2190z00zz__threadz00, BgL_cz00_3476);
							FAILURE(BgL_auxz00_5376, BFALSE, BFALSE);
						}
					BgL_tmpz00_5372 =
						BGl_conditionzd2variablezd2broadcastz12z12zz__threadz00
						(BgL_auxz00_5373);
				}
				return BBOOL(BgL_tmpz00_5372);
			}
		}

	}



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

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

					BgL_v1162z00_1313 = create_vector(1L);
					VECTOR_SET(BgL_v1162z00_1313, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2196z00zz__threadz00, BGl_proc2195z00zz__threadz00,
							BGl_proc2194z00zz__threadz00, ((bool_t) 1), ((bool_t) 0), BFALSE,
							BFALSE, BGl_symbol2198z00zz__threadz00));
					BgL_arg1359z00_1301 = BgL_v1162z00_1313;
				}
				{	/* Llib/thread.scm 161 */
					obj_t BgL_v1163z00_1324;

					BgL_v1163z00_1324 = create_vector(0L);
					BgL_arg1360z00_1302 = BgL_v1163z00_1324;
				}
				BGl_threadzd2backendzd2zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2202z00zz__threadz00, BGl_symbol2203z00zz__threadz00,
					BGl_objectz00zz__objectz00, 20365L, BGl_proc2201z00zz__threadz00,
					BGl_proc2200z00zz__threadz00, BFALSE, BGl_proc2199z00zz__threadz00,
					BFALSE, BgL_arg1359z00_1301, BgL_arg1360z00_1302);
			}
			{	/* Llib/thread.scm 164 */
				obj_t BgL_arg1373z00_1330;
				obj_t BgL_arg1374z00_1331;

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

					BgL_v1164z00_1337 = create_vector(3L);
					VECTOR_SET(BgL_v1164z00_1337, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2196z00zz__threadz00, BGl_proc2207z00zz__threadz00,
							BGl_proc2206z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2205z00zz__threadz00, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1164z00_1337, 1L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2212z00zz__threadz00, BGl_proc2211z00zz__threadz00,
							BGl_proc2210z00zz__threadz00, ((bool_t) 0), ((bool_t) 1), BFALSE,
							BFALSE, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1164z00_1337, 2L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2216z00zz__threadz00, BGl_proc2215z00zz__threadz00,
							BGl_proc2214z00zz__threadz00, ((bool_t) 0), ((bool_t) 1), BFALSE,
							BFALSE, BGl_symbol2208z00zz__threadz00));
					BgL_arg1373z00_1330 = BgL_v1164z00_1337;
				}
				{	/* Llib/thread.scm 164 */
					obj_t BgL_v1165z00_1371;

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

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

							BgL_arg1400z00_1373 =
								MAKE_YOUNG_PAIR(BGl_proc2218z00zz__threadz00,
								BGl_proc2219z00zz__threadz00);
							BgL_arg1399z00_1372 =
								MAKE_YOUNG_PAIR(BINT(0L), BgL_arg1400z00_1373);
						}
						VECTOR_SET(BgL_v1165z00_1371, 0L, BgL_arg1399z00_1372);
					}
					{	/* Llib/thread.scm 168 */
						obj_t BgL_arg1407z00_1389;

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

							BgL_arg1408z00_1390 =
								MAKE_YOUNG_PAIR(BGl_proc2220z00zz__threadz00,
								BGl_proc2221z00zz__threadz00);
							BgL_arg1407z00_1389 =
								MAKE_YOUNG_PAIR(BINT(1L), BgL_arg1408z00_1390);
						}
						VECTOR_SET(BgL_v1165z00_1371, 1L, BgL_arg1407z00_1389);
					}
					BgL_arg1374z00_1331 = BgL_v1165z00_1371;
				}
				BGl_threadz00zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2169z00zz__threadz00, BGl_symbol2203z00zz__threadz00,
					BGl_objectz00zz__objectz00, 35587L, BFALSE,
					BGl_proc2223z00zz__threadz00,
					BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
					BGl_proc2222z00zz__threadz00, BFALSE, BgL_arg1373z00_1330,
					BgL_arg1374z00_1331);
			}
			{	/* Llib/thread.scm 170 */
				obj_t BgL_arg1418z00_1411;
				obj_t BgL_arg1419z00_1412;

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

					BgL_v1166z00_1430 = create_vector(6L);
					VECTOR_SET(BgL_v1166z00_1430, 0L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2226z00zz__threadz00, BGl_proc2225z00zz__threadz00,
							BGl_proc2224z00zz__threadz00, ((bool_t) 1), ((bool_t) 0), BFALSE,
							BFALSE, BGl_symbol2228z00zz__threadz00));
					VECTOR_SET(BgL_v1166z00_1430, 1L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2232z00zz__threadz00, BGl_proc2231z00zz__threadz00,
							BGl_proc2230z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2229z00zz__threadz00, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1166z00_1430, 2L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2237z00zz__threadz00, BGl_proc2236z00zz__threadz00,
							BGl_proc2235z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2234z00zz__threadz00, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1166z00_1430, 3L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2242z00zz__threadz00, BGl_proc2241z00zz__threadz00,
							BGl_proc2240z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2239z00zz__threadz00, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1166z00_1430, 4L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2247z00zz__threadz00, BGl_proc2246z00zz__threadz00,
							BGl_proc2245z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2244z00zz__threadz00, BGl_symbol2208z00zz__threadz00));
					VECTOR_SET(BgL_v1166z00_1430, 5L,
						BGl_makezd2classzd2fieldz00zz__objectz00
						(BGl_symbol2252z00zz__threadz00, BGl_proc2251z00zz__threadz00,
							BGl_proc2250z00zz__threadz00, ((bool_t) 0), ((bool_t) 0), BFALSE,
							BGl_proc2249z00zz__threadz00, BGl_symbol2198z00zz__threadz00));
					BgL_arg1418z00_1411 = BgL_v1166z00_1430;
				}
				{	/* Llib/thread.scm 170 */
					obj_t BgL_v1167z00_1506;

					BgL_v1167z00_1506 = create_vector(0L);
					BgL_arg1419z00_1412 = BgL_v1167z00_1506;
				}
				BGl_nothreadz00zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2257z00zz__threadz00, BGl_symbol2203z00zz__threadz00,
					BGl_threadz00zz__threadz00, 50609L, BGl_proc2256z00zz__threadz00,
					BGl_proc2255z00zz__threadz00,
					BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
					BGl_proc2254z00zz__threadz00, BFALSE, BgL_arg1418z00_1411,
					BgL_arg1419z00_1412);
			}
			{	/* Llib/thread.scm 159 */
				obj_t BgL_arg1473z00_1513;
				obj_t BgL_arg1474z00_1514;

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

					BgL_v1168z00_1525 = create_vector(0L);
					BgL_arg1473z00_1513 = BgL_v1168z00_1525;
				}
				{	/* Llib/thread.scm 159 */
					obj_t BgL_v1169z00_1526;

					BgL_v1169z00_1526 = create_vector(0L);
					BgL_arg1474z00_1514 = BgL_v1169z00_1526;
				}
				return (BGl_nothreadzd2backendzd2zz__threadz00 =
					BGl_registerzd2classz12zc0zz__objectz00
					(BGl_symbol2261z00zz__threadz00, BGl_symbol2203z00zz__threadz00,
						BGl_threadzd2backendzd2zz__threadz00, 1284L,
						BGl_proc2260z00zz__threadz00, BGl_proc2259z00zz__threadz00, BFALSE,
						BGl_proc2258z00zz__threadz00, BFALSE, BgL_arg1473z00_1513,
						BgL_arg1474z00_1514), BUNSPEC);
			}
		}

	}



/* &<@anonymous:1479> */
	obj_t BGl_z62zc3z04anonymousza31479ze3ze5zz__threadz00(obj_t BgL_envz00_3521,
		obj_t BgL_new1056z00_3522)
	{
		{	/* Llib/thread.scm 159 */
			{
				BgL_nothreadzd2backendzd2_bglt BgL_auxz00_5422;

				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt)
									((BgL_nothreadzd2backendzd2_bglt) BgL_new1056z00_3522))))->
						BgL_namez00) = ((obj_t) BGl_string2263z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5422 =
					((BgL_nothreadzd2backendzd2_bglt) BgL_new1056z00_3522);
				return ((obj_t) BgL_auxz00_5422);
			}
		}

	}



/* &lambda1477 */
	BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1477z62zz__threadz00(obj_t
		BgL_envz00_3523)
	{
		{	/* Llib/thread.scm 159 */
			{	/* Llib/thread.scm 159 */
				BgL_nothreadzd2backendzd2_bglt BgL_new1055z00_3993;

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

					BgL_arg1478z00_3994 =
						BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1055z00_3993), BgL_arg1478z00_3994);
				}
				return BgL_new1055z00_3993;
			}
		}

	}



/* &lambda1475 */
	BgL_nothreadzd2backendzd2_bglt BGl_z62lambda1475z62zz__threadz00(obj_t
		BgL_envz00_3524, obj_t BgL_name1054z00_3525)
	{
		{	/* Llib/thread.scm 159 */
			{	/* Llib/thread.scm 159 */
				BgL_nothreadzd2backendzd2_bglt BgL_new1118z00_3996;

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

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

						BgL_arg1476z00_3998 =
							BGL_CLASS_NUM(BGl_nothreadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1117z00_3997), BgL_arg1476z00_3998);
					}
					BgL_new1118z00_3996 = BgL_new1117z00_3997;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1118z00_3996)))->
						BgL_namez00) = ((obj_t) ((obj_t) BgL_name1054z00_3525)), BUNSPEC);
				return BgL_new1118z00_3996;
			}
		}

	}



/* &<@anonymous:1426> */
	obj_t BGl_z62zc3z04anonymousza31426ze3ze5zz__threadz00(obj_t BgL_envz00_3526,
		obj_t BgL_new1052z00_3527)
	{
		{	/* Llib/thread.scm 170 */
			{
				BgL_nothreadz00_bglt BgL_auxz00_5439;

				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt)
									((BgL_nothreadz00_bglt) BgL_new1052z00_3527))))->
						BgL_namez00) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_bodyz00) =
					((obj_t) BGl_conszd2envzd2zz__r4_pairs_and_lists_6_3z00), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_z52specificz52) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_z52cleanupz52) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_endzd2resultzd2) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_endzd2exceptionzd2) =
					((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(((BgL_nothreadz00_bglt)
									BgL_new1052z00_3527)))->BgL_z52namez52) =
					((obj_t) BGl_string2263z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5439 = ((BgL_nothreadz00_bglt) BgL_new1052z00_3527);
				return ((obj_t) BgL_auxz00_5439);
			}
		}

	}



/* &lambda1424 */
	BgL_nothreadz00_bglt BGl_z62lambda1424z62zz__threadz00(obj_t BgL_envz00_3528)
	{
		{	/* Llib/thread.scm 170 */
			{	/* Llib/thread.scm 170 */
				BgL_nothreadz00_bglt BgL_new1051z00_4000;

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

					BgL_arg1425z00_4001 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1051z00_4000), BgL_arg1425z00_4001);
				}
				return BgL_new1051z00_4000;
			}
		}

	}



/* &lambda1420 */
	BgL_nothreadz00_bglt BGl_z62lambda1420z62zz__threadz00(obj_t BgL_envz00_3529,
		obj_t BgL_name1044z00_3530, obj_t BgL_body1045z00_3531,
		obj_t BgL_z52specific1046z52_3532, obj_t BgL_z52cleanup1047z52_3533,
		obj_t BgL_endzd2result1048zd2_3534, obj_t BgL_endzd2exception1049zd2_3535,
		obj_t BgL_z52name1050z52_3536)
	{
		{	/* Llib/thread.scm 170 */
			{	/* Llib/thread.scm 170 */
				BgL_nothreadz00_bglt BgL_new1116z00_4004;

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

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

						BgL_arg1423z00_4006 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1113z00_4005), BgL_arg1423z00_4006);
					}
					BgL_new1116z00_4004 = BgL_new1113z00_4005;
				}
				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1116z00_4004)))->BgL_namez00) =
					((obj_t) BgL_name1044z00_3530), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->BgL_bodyz00) =
					((obj_t) ((obj_t) BgL_body1045z00_3531)), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->
						BgL_z52specificz52) =
					((obj_t) BgL_z52specific1046z52_3532), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->
						BgL_z52cleanupz52) = ((obj_t) BgL_z52cleanup1047z52_3533), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->
						BgL_endzd2resultzd2) =
					((obj_t) BgL_endzd2result1048zd2_3534), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->
						BgL_endzd2exceptionzd2) =
					((obj_t) BgL_endzd2exception1049zd2_3535), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1116z00_4004))->
						BgL_z52namez52) =
					((obj_t) ((obj_t) BgL_z52name1050z52_3536)), BUNSPEC);
				{	/* Llib/thread.scm 170 */
					obj_t BgL_fun1422z00_4007;

					BgL_fun1422z00_4007 =
						BGl_classzd2constructorzd2zz__objectz00
						(BGl_nothreadz00zz__threadz00);
					(VA_PROCEDUREP(BgL_fun1422z00_4007) ? ((obj_t(*)(obj_t,
									...))
							PROCEDURE_ENTRY(BgL_fun1422z00_4007)) (BgL_fun1422z00_4007,
							((obj_t) BgL_new1116z00_4004), BEOA) : ((obj_t(*)(obj_t,
									obj_t))
							PROCEDURE_ENTRY(BgL_fun1422z00_4007)) (BgL_fun1422z00_4007,
							((obj_t) BgL_new1116z00_4004)));
				}
				return BgL_new1116z00_4004;
			}
		}

	}



/* &<@anonymous:1468> */
	obj_t BGl_z62zc3z04anonymousza31468ze3ze5zz__threadz00(obj_t BgL_envz00_3537)
	{
		{	/* Llib/thread.scm 170 */
			return BGl_string2264z00zz__threadz00;
		}

	}



/* &lambda1467 */
	obj_t BGl_z62lambda1467z62zz__threadz00(obj_t BgL_envz00_3538,
		obj_t BgL_oz00_3539, obj_t BgL_vz00_3540)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3539)))->BgL_z52namez52) =
				((obj_t) ((obj_t) BgL_vz00_3540)), BUNSPEC);
		}

	}



/* &lambda1466 */
	obj_t BGl_z62lambda1466z62zz__threadz00(obj_t BgL_envz00_3541,
		obj_t BgL_oz00_3542)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3542)))->BgL_z52namez52);
		}

	}



/* &<@anonymous:1461> */
	obj_t BGl_z62zc3z04anonymousza31461ze3ze5zz__threadz00(obj_t BgL_envz00_3543)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1460 */
	obj_t BGl_z62lambda1460z62zz__threadz00(obj_t BgL_envz00_3544,
		obj_t BgL_oz00_3545, obj_t BgL_vz00_3546)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3545)))->
					BgL_endzd2exceptionzd2) = ((obj_t) BgL_vz00_3546), BUNSPEC);
		}

	}



/* &lambda1459 */
	obj_t BGl_z62lambda1459z62zz__threadz00(obj_t BgL_envz00_3547,
		obj_t BgL_oz00_3548)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3548)))->BgL_endzd2exceptionzd2);
		}

	}



/* &<@anonymous:1454> */
	obj_t BGl_z62zc3z04anonymousza31454ze3ze5zz__threadz00(obj_t BgL_envz00_3549)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1453 */
	obj_t BGl_z62lambda1453z62zz__threadz00(obj_t BgL_envz00_3550,
		obj_t BgL_oz00_3551, obj_t BgL_vz00_3552)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3551)))->BgL_endzd2resultzd2) =
				((obj_t) BgL_vz00_3552), BUNSPEC);
		}

	}



/* &lambda1452 */
	obj_t BGl_z62lambda1452z62zz__threadz00(obj_t BgL_envz00_3553,
		obj_t BgL_oz00_3554)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3554)))->BgL_endzd2resultzd2);
		}

	}



/* &<@anonymous:1447> */
	obj_t BGl_z62zc3z04anonymousza31447ze3ze5zz__threadz00(obj_t BgL_envz00_3555)
	{
		{	/* Llib/thread.scm 170 */
			return BBOOL(((bool_t) 0));
		}

	}



/* &lambda1446 */
	obj_t BGl_z62lambda1446z62zz__threadz00(obj_t BgL_envz00_3556,
		obj_t BgL_oz00_3557, obj_t BgL_vz00_3558)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3557)))->BgL_z52cleanupz52) =
				((obj_t) BgL_vz00_3558), BUNSPEC);
		}

	}



/* &lambda1445 */
	obj_t BGl_z62lambda1445z62zz__threadz00(obj_t BgL_envz00_3559,
		obj_t BgL_oz00_3560)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3560)))->BgL_z52cleanupz52);
		}

	}



/* &<@anonymous:1440> */
	obj_t BGl_z62zc3z04anonymousza31440ze3ze5zz__threadz00(obj_t BgL_envz00_3561)
	{
		{	/* Llib/thread.scm 170 */
			return BUNSPEC;
		}

	}



/* &lambda1439 */
	obj_t BGl_z62lambda1439z62zz__threadz00(obj_t BgL_envz00_3562,
		obj_t BgL_oz00_3563, obj_t BgL_vz00_3564)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3563)))->BgL_z52specificz52) =
				((obj_t) BgL_vz00_3564), BUNSPEC);
		}

	}



/* &lambda1438 */
	obj_t BGl_z62lambda1438z62zz__threadz00(obj_t BgL_envz00_3565,
		obj_t BgL_oz00_3566)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3566)))->BgL_z52specificz52);
		}

	}



/* &lambda1433 */
	obj_t BGl_z62lambda1433z62zz__threadz00(obj_t BgL_envz00_3567,
		obj_t BgL_oz00_3568, obj_t BgL_vz00_3569)
	{
		{	/* Llib/thread.scm 170 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_oz00_3568)))->BgL_bodyz00) = ((obj_t)
					((obj_t) BgL_vz00_3569)), BUNSPEC);
		}

	}



/* &lambda1432 */
	obj_t BGl_z62lambda1432z62zz__threadz00(obj_t BgL_envz00_3570,
		obj_t BgL_oz00_3571)
	{
		{	/* Llib/thread.scm 170 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_oz00_3571)))->BgL_bodyz00);
		}

	}



/* &<@anonymous:1377> */
	obj_t BGl_z62zc3z04anonymousza31377ze3ze5zz__threadz00(obj_t BgL_envz00_3572,
		obj_t BgL_new1042z00_3573)
	{
		{	/* Llib/thread.scm 164 */
			{
				BgL_threadz00_bglt BgL_auxz00_5508;

				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1042z00_3573)))->BgL_namez00) =
					((obj_t) BUNSPEC), BUNSPEC);
				BgL_auxz00_5508 = ((BgL_threadz00_bglt) BgL_new1042z00_3573);
				return ((obj_t) BgL_auxz00_5508);
			}
		}

	}



/* &lambda1375 */
	BgL_threadz00_bglt BGl_z62lambda1375z62zz__threadz00(obj_t BgL_envz00_3574)
	{
		{	/* Llib/thread.scm 164 */
			{	/* Llib/thread.scm 164 */
				BgL_threadz00_bglt BgL_new1041z00_4023;

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

					BgL_arg1376z00_4024 = BGL_CLASS_NUM(BGl_threadz00zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1041z00_4023), BgL_arg1376z00_4024);
				}
				return BgL_new1041z00_4023;
			}
		}

	}



/* &<@anonymous:1413> */
	obj_t BGl_z62zc3z04anonymousza31413ze3ze5zz__threadz00(obj_t BgL_envz00_3575,
		obj_t BgL_oz00_3576, obj_t BgL_vz00_3577)
	{
		{	/* Llib/thread.scm 168 */
			return
				BGl_threadzd2cleanupzd2setz12z12zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3576), BgL_vz00_3577);
		}

	}



/* &<@anonymous:1411> */
	obj_t BGl_z62zc3z04anonymousza31411ze3ze5zz__threadz00(obj_t BgL_envz00_3578,
		obj_t BgL_oz00_3579)
	{
		{	/* Llib/thread.scm 168 */
			return
				BGl_threadzd2cleanupzd2zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3579));
		}

	}



/* &<@anonymous:1405> */
	obj_t BGl_z62zc3z04anonymousza31405ze3ze5zz__threadz00(obj_t BgL_envz00_3580,
		obj_t BgL_oz00_3581, obj_t BgL_vz00_3582)
	{
		{	/* Llib/thread.scm 167 */
			return
				BGl_threadzd2specificzd2setz12z12zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3581), BgL_vz00_3582);
		}

	}



/* &<@anonymous:1403> */
	obj_t BGl_z62zc3z04anonymousza31403ze3ze5zz__threadz00(obj_t BgL_envz00_3583,
		obj_t BgL_oz00_3584)
	{
		{	/* Llib/thread.scm 167 */
			return
				BGl_threadzd2specificzd2zz__threadz00(
				((BgL_threadz00_bglt) BgL_oz00_3584));
		}

	}



/* &<@anonymous:1398> */
	obj_t BGl_z62zc3z04anonymousza31398ze3ze5zz__threadz00(obj_t BgL_envz00_3585,
		obj_t BgL_oz00_3586, obj_t BgL_vz00_3587)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2setterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3586), (int) (1L), BgL_vz00_3587);
		}

	}



/* &<@anonymous:1397> */
	obj_t BGl_z62zc3z04anonymousza31397ze3ze5zz__threadz00(obj_t BgL_envz00_3588,
		obj_t BgL_oz00_3589)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2getterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3589), (int) (1L));
		}

	}



/* &<@anonymous:1392> */
	obj_t BGl_z62zc3z04anonymousza31392ze3ze5zz__threadz00(obj_t BgL_envz00_3590,
		obj_t BgL_oz00_3591, obj_t BgL_vz00_3592)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2setterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3591), (int) (0L), BgL_vz00_3592);
		}

	}



/* &<@anonymous:1391> */
	obj_t BGl_z62zc3z04anonymousza31391ze3ze5zz__threadz00(obj_t BgL_envz00_3593,
		obj_t BgL_oz00_3594)
	{
		{	/* Llib/thread.scm 164 */
			return
				BGl_callzd2virtualzd2getterz00zz__objectz00(
				((BgL_objectz00_bglt) BgL_oz00_3594), (int) (0L));
		}

	}



/* &<@anonymous:1387> */
	obj_t BGl_z62zc3z04anonymousza31387ze3ze5zz__threadz00(obj_t BgL_envz00_3595)
	{
		{	/* Llib/thread.scm 164 */
			return BGl_gensymz00zz__r4_symbols_6_4z00(BGl_symbol2169z00zz__threadz00);
		}

	}



/* &lambda1386 */
	obj_t BGl_z62lambda1386z62zz__threadz00(obj_t BgL_envz00_3596,
		obj_t BgL_oz00_3597, obj_t BgL_vz00_3598)
	{
		{	/* Llib/thread.scm 164 */
			return
				((((BgL_threadz00_bglt) COBJECT(
							((BgL_threadz00_bglt) BgL_oz00_3597)))->BgL_namez00) =
				((obj_t) BgL_vz00_3598), BUNSPEC);
		}

	}



/* &lambda1385 */
	obj_t BGl_z62lambda1385z62zz__threadz00(obj_t BgL_envz00_3599,
		obj_t BgL_oz00_3600)
	{
		{	/* Llib/thread.scm 164 */
			return
				(((BgL_threadz00_bglt) COBJECT(
						((BgL_threadz00_bglt) BgL_oz00_3600)))->BgL_namez00);
		}

	}



/* &<@anonymous:1365> */
	obj_t BGl_z62zc3z04anonymousza31365ze3ze5zz__threadz00(obj_t BgL_envz00_3601,
		obj_t BgL_new1039z00_3602)
	{
		{	/* Llib/thread.scm 161 */
			{
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5542;

				((((BgL_threadzd2backendzd2_bglt) COBJECT(
								((BgL_threadzd2backendzd2_bglt) BgL_new1039z00_3602)))->
						BgL_namez00) = ((obj_t) BGl_string2263z00zz__threadz00), BUNSPEC);
				BgL_auxz00_5542 = ((BgL_threadzd2backendzd2_bglt) BgL_new1039z00_3602);
				return ((obj_t) BgL_auxz00_5542);
			}
		}

	}



/* &lambda1363 */
	BgL_threadzd2backendzd2_bglt BGl_z62lambda1363z62zz__threadz00(obj_t
		BgL_envz00_3603)
	{
		{	/* Llib/thread.scm 161 */
			{	/* Llib/thread.scm 161 */
				BgL_threadzd2backendzd2_bglt BgL_new1038z00_4028;

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

					BgL_arg1364z00_4029 =
						BGL_CLASS_NUM(BGl_threadzd2backendzd2zz__threadz00);
					BGL_OBJECT_CLASS_NUM_SET(
						((BgL_objectz00_bglt) BgL_new1038z00_4028), BgL_arg1364z00_4029);
				}
				return BgL_new1038z00_4028;
			}
		}

	}



/* &lambda1361 */
	BgL_threadzd2backendzd2_bglt BGl_z62lambda1361z62zz__threadz00(obj_t
		BgL_envz00_3604, obj_t BgL_name1037z00_3605)
	{
		{	/* Llib/thread.scm 161 */
			{	/* Llib/thread.scm 161 */
				BgL_threadzd2backendzd2_bglt BgL_new1112z00_4031;

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

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

						BgL_arg1362z00_4033 =
							BGL_CLASS_NUM(BGl_threadzd2backendzd2zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1111z00_4032), BgL_arg1362z00_4033);
					}
					BgL_new1112z00_4031 = BgL_new1111z00_4032;
				}
				((((BgL_threadzd2backendzd2_bglt) COBJECT(BgL_new1112z00_4031))->
						BgL_namez00) = ((obj_t) ((obj_t) BgL_name1037z00_3605)), BUNSPEC);
				return BgL_new1112z00_4031;
			}
		}

	}



/* &lambda1370 */
	obj_t BGl_z62lambda1370z62zz__threadz00(obj_t BgL_envz00_3606,
		obj_t BgL_oz00_3607, obj_t BgL_vz00_3608)
	{
		{	/* Llib/thread.scm 161 */
			return
				((((BgL_threadzd2backendzd2_bglt) COBJECT(
							((BgL_threadzd2backendzd2_bglt) BgL_oz00_3607)))->BgL_namez00) =
				((obj_t) ((obj_t) BgL_vz00_3608)), BUNSPEC);
		}

	}



/* &lambda1369 */
	obj_t BGl_z62lambda1369z62zz__threadz00(obj_t BgL_envz00_3609,
		obj_t BgL_oz00_3610)
	{
		{	/* Llib/thread.scm 161 */
			return
				(((BgL_threadzd2backendzd2_bglt) COBJECT(
						((BgL_threadzd2backendzd2_bglt) BgL_oz00_3610)))->BgL_namez00);
		}

	}



/* generic-init */
	obj_t BGl_genericzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
				BGl_proc2265z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2266z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
				BGl_proc2267z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2268z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2mutexzd2initializa7ez12zd2envz67zz__threadz00,
				BGl_proc2269z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2270z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_tbzd2condvarzd2initializa7ez12zd2envz67zz__threadz00,
				BGl_proc2271z00zz__threadz00, BGl_threadzd2backendzd2zz__threadz00,
				BGl_string2272z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2initializa7ez12zd2envzb5zz__threadz00,
				BGl_proc2273z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2274z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2startz12zd2envz12zz__threadz00,
				BGl_proc2275z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2276z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
				BGl_proc2277z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2278z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2joinz12zd2envz12zz__threadz00,
				BGl_proc2279z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2280z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
				BGl_proc2281z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2282z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2killz12zd2envz12zz__threadz00,
				BGl_proc2283z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2284z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2specificzd2envz00zz__threadz00,
				BGl_proc2285z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2286z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
				BGl_proc2287z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2288z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2cleanupzd2envz00zz__threadz00,
				BGl_proc2289z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2290z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
				BGl_proc2291z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2292z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2namezd2envz00zz__threadz00, BGl_proc2293z00zz__threadz00,
				BGl_threadz00zz__threadz00, BGl_string2294z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
				BGl_proc2295z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2296z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
				BGl_proc2297z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2298z00zz__threadz00);
			BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
				BGl_proc2299z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2300z00zz__threadz00);
			return
				BGl_registerzd2genericz12zc0zz__objectz00
				(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
				BGl_proc2301z00zz__threadz00, BGl_threadz00zz__threadz00,
				BGl_string2302z00zz__threadz00);
		}

	}



/* &%user-thread-yield!1230 */
	obj_t BGl_z62z52userzd2threadzd2yieldz121230z22zz__threadz00(obj_t
		BgL_envz00_3632, obj_t BgL_oz00_3633)
	{
		{	/* Llib/thread.scm 500 */
			return BUNSPEC;
		}

	}



/* &%user-thread-sleep!1228 */
	obj_t BGl_z62z52userzd2threadzd2sleepz121228z22zz__threadz00(obj_t
		BgL_envz00_3634, obj_t BgL_oz00_3635, obj_t BgL_dz00_3636)
	{
		{	/* Llib/thread.scm 473 */
			if (BGL_DATEP(BgL_dz00_3636))
				{	/* Llib/thread.scm 476 */
					long BgL_cdtz00_4039;

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

						BgL_dtz00_4040 = bgl_date_to_seconds(BgL_dz00_3636);
						{	/* Llib/thread.scm 477 */
							obj_t BgL_az00_4041;

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

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

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

										BgL_tmpz00_5587 = (BgL_dtz00_4040 - BgL_cdtz00_4039);
										BgL_res1945z00_4043 = (long) (BgL_tmpz00_5587);
									}
									BgL_a1151z00_4042 = BgL_res1945z00_4043;
								}
								{	/* Llib/thread.scm 478 */

									BgL_az00_4041 =
										BGl_2za2za2zz__r4_numbers_6_5z00(make_belong
										(BgL_a1151z00_4042), BINT(1000000L));
							}}
							{	/* Llib/thread.scm 478 */

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

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

										BgL_n1z00_4044 = BELONG_TO_LONG(BgL_az00_4041);
										BgL_test2657z00_5593 = (BgL_n1z00_4044 > ((long) 0));
									}
									if (BgL_test2657z00_5593)
										{	/* Llib/thread.scm 479 */
											long BgL_arg1503z00_4045;

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

												BgL_xz00_4046 = BELONG_TO_LONG(BgL_az00_4041);
												BgL_arg1503z00_4045 = (long) (BgL_xz00_4046);
											}
											bgl_sleep(BgL_arg1503z00_4045);
											BUNSPEC;
											return BINT(BgL_arg1503z00_4045);
										}
									else
										{	/* Llib/thread.scm 479 */
											return BFALSE;
										}
								}
							}
						}
					}
				}
			else
				{	/* Llib/thread.scm 475 */
					if (INTEGERP(BgL_dz00_3636))
						{	/* Llib/thread.scm 481 */
							obj_t BgL_arg1507z00_4047;

							BgL_arg1507z00_4047 = BINT(((long) CINT(BgL_dz00_3636) * 1000L));
							{	/* Llib/thread.scm 481 */
								long BgL_msz00_4048;

								BgL_msz00_4048 = (long) CINT(BgL_arg1507z00_4047);
								bgl_sleep(BgL_msz00_4048);
								BUNSPEC;
								return BINT(BgL_msz00_4048);
							}
						}
					else
						{	/* Llib/thread.scm 480 */
							if (ELONGP(BgL_dz00_3636))
								{	/* Llib/thread.scm 483 */
									long BgL_arg1509z00_4049;

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

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

											BgL_xz00_4051 = BELONG_TO_LONG(BgL_dz00_3636);
											BgL_a1153z00_4050 = (long) (BgL_xz00_4051);
										}
										{	/* Llib/thread.scm 483 */

											BgL_arg1509z00_4049 = (BgL_a1153z00_4050 * 1000L);
									}}
									bgl_sleep(BgL_arg1509z00_4049);
									BUNSPEC;
									return BINT(BgL_arg1509z00_4049);
								}
							else
								{	/* Llib/thread.scm 482 */
									if (LLONGP(BgL_dz00_3636))
										{	/* Llib/thread.scm 485 */
											long BgL_arg1512z00_4052;

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

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

													BgL_tmpz00_5617 = BLLONG_TO_LLONG(BgL_dz00_3636);
													BgL_a1155z00_4053 = LLONG_TO_LONG(BgL_tmpz00_5617);
												}
												{	/* Llib/thread.scm 485 */

													BgL_arg1512z00_4052 = (BgL_a1155z00_4053 * 1000L);
											}}
											bgl_sleep(BgL_arg1512z00_4052);
											BUNSPEC;
											return BINT(BgL_arg1512z00_4052);
										}
									else
										{	/* Llib/thread.scm 486 */
											bool_t BgL_test2661z00_5623;

											if (INTEGERP(BgL_dz00_3636))
												{	/* Llib/thread.scm 486 */
													BgL_test2661z00_5623 = ((bool_t) 1);
												}
											else
												{	/* Llib/thread.scm 486 */
													BgL_test2661z00_5623 = REALP(BgL_dz00_3636);
												}
											if (BgL_test2661z00_5623)
												{	/* Llib/thread.scm 487 */
													long BgL_arg1515z00_4054;

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

														if (REALP(BgL_dz00_3636))
															{	/* Llib/thread.scm 487 */
																BgL_arg1516z00_4055 =
																	(REAL_TO_DOUBLE(BgL_dz00_3636) *
																	((double) 1000000.0));
															}
														else
															{	/* Llib/thread.scm 487 */
																BgL_arg1516z00_4055 =
																	(BGl_numberzd2ze3flonumz31zz__r4_numbers_6_5z00
																	(BgL_dz00_3636) * ((double) 1000000.0));
															}
														BgL_arg1515z00_4054 = (long) (BgL_arg1516z00_4055);
													}
													bgl_sleep(BgL_arg1515z00_4054);
													BUNSPEC;
													return BINT(BgL_arg1515z00_4054);
												}
											else
												{	/* Llib/thread.scm 486 */
													return
														BGl_bigloozd2typezd2errorz00zz__errorz00
														(BGl_symbol2303z00zz__threadz00,
														BGl_string2305z00zz__threadz00, BgL_dz00_3636);
												}
										}
								}
						}
				}
		}

	}



/* &%user-current-thread1226 */
	obj_t BGl_z62z52userzd2currentzd2thread1226z30zz__threadz00(obj_t
		BgL_envz00_3637, obj_t BgL_oz00_3638)
	{
		{	/* Llib/thread.scm 451 */
			return ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3638));
		}

	}



/* &thread-name-set!1219 */
	obj_t BGl_z62threadzd2namezd2setz121219z70zz__threadz00(obj_t BgL_envz00_3639,
		obj_t BgL_thz00_3640, obj_t BgL_vz00_3641)
	{
		{	/* Llib/thread.scm 440 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2306z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3640)));
		}

	}



/* &thread-name1217 */
	obj_t BGl_z62threadzd2name1217zb0zz__threadz00(obj_t BgL_envz00_3642,
		obj_t BgL_thz00_3643)
	{
		{	/* Llib/thread.scm 435 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2308z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3643)));
		}

	}



/* &thread-cleanup-set!1215 */
	obj_t BGl_z62threadzd2cleanupzd2setz121215z70zz__threadz00(obj_t
		BgL_envz00_3644, obj_t BgL_thz00_3645, obj_t BgL_vz00_3646)
	{
		{	/* Llib/thread.scm 430 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2309z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3645)));
		}

	}



/* &thread-cleanup1213 */
	obj_t BGl_z62threadzd2cleanup1213zb0zz__threadz00(obj_t BgL_envz00_3647,
		obj_t BgL_thz00_3648)
	{
		{	/* Llib/thread.scm 425 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2310z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3648)));
		}

	}



/* &thread-specific-set!1210 */
	obj_t BGl_z62threadzd2specificzd2setz121210z70zz__threadz00(obj_t
		BgL_envz00_3649, obj_t BgL_thz00_3650, obj_t BgL_vz00_3651)
	{
		{	/* Llib/thread.scm 420 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2311z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3650)));
		}

	}



/* &thread-specific1208 */
	obj_t BGl_z62threadzd2specific1208zb0zz__threadz00(obj_t BgL_envz00_3652,
		obj_t BgL_thz00_3653)
	{
		{	/* Llib/thread.scm 415 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2312z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3653)));
		}

	}



/* &thread-kill!1206 */
	obj_t BGl_z62threadzd2killz121206za2zz__threadz00(obj_t BgL_envz00_3654,
		obj_t BgL_thz00_3655, obj_t BgL_nz00_3656)
	{
		{	/* Llib/thread.scm 410 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2313z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3655)));
		}

	}



/* &thread-terminate!1204 */
	obj_t BGl_z62threadzd2terminatez121204za2zz__threadz00(obj_t BgL_envz00_3657,
		obj_t BgL_thz00_3658)
	{
		{	/* Llib/thread.scm 405 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2314z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3658)));
		}

	}



/* &thread-join!1202 */
	obj_t BGl_z62threadzd2joinz121202za2zz__threadz00(obj_t BgL_envz00_3659,
		obj_t BgL_thz00_3660, obj_t BgL_timeoutz00_3661)
	{
		{	/* Llib/thread.scm 400 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2315z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3660)));
		}

	}



/* &thread-start-joinabl1200 */
	obj_t BGl_z62threadzd2startzd2joinabl1200z62zz__threadz00(obj_t
		BgL_envz00_3662, obj_t BgL_thz00_3663)
	{
		{	/* Llib/thread.scm 395 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2316z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3663)));
		}

	}



/* &thread-start!1198 */
	obj_t BGl_z62threadzd2startz121198za2zz__threadz00(obj_t BgL_envz00_3664,
		obj_t BgL_thz00_3665, obj_t BgL_scz00_3666)
	{
		{	/* Llib/thread.scm 390 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2317z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadz00_bglt) BgL_thz00_3665)));
		}

	}



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

	}



/* &tb-condvar-initializ1187 */
	obj_t BGl_z62tbzd2condvarzd2initializa71187zc5zz__threadz00(obj_t
		BgL_envz00_3669, obj_t BgL_tbz00_3670, obj_t BgL_condvarz00_3671)
	{
		{	/* Llib/thread.scm 355 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2318z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3670)));
		}

	}



/* &tb-mutex-initialize!1185 */
	obj_t BGl_z62tbzd2mutexzd2initializa7ez121185zd7zz__threadz00(obj_t
		BgL_envz00_3672, obj_t BgL_tbz00_3673, obj_t BgL_mutexz00_3674)
	{
		{	/* Llib/thread.scm 350 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2319z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3673)));
		}

	}



/* &tb-current-thread1179 */
	obj_t BGl_z62tbzd2currentzd2thread1179z62zz__threadz00(obj_t BgL_envz00_3675,
		obj_t BgL_tbz00_3676)
	{
		{	/* Llib/thread.scm 326 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2320z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3676)));
		}

	}



/* &tb-make-thread1177 */
	obj_t BGl_z62tbzd2makezd2thread1177z62zz__threadz00(obj_t BgL_envz00_3677,
		obj_t BgL_tbz00_3678, obj_t BgL_bodyz00_3679, obj_t BgL_namez00_3680)
	{
		{	/* Llib/thread.scm 321 */
			return
				BGl_errorz00zz__errorz00(BGl_symbol2321z00zz__threadz00,
				BGl_string2307z00zz__threadz00,
				((obj_t) ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3678)));
		}

	}



/* 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_1643;

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

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

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

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

								BgL_offsetz00_2480 = (int) (BgL_objzd2classzd2numz00_2476);
								{	/* Llib/thread.scm 321 */
									long BgL_offsetz00_2481;

									BgL_offsetz00_2481 =
										((long) (BgL_offsetz00_2480) - OBJECT_TYPE);
									{	/* Llib/thread.scm 321 */
										long BgL_modz00_2482;

										BgL_modz00_2482 =
											(BgL_offsetz00_2481 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 321 */
											long BgL_restz00_2484;

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

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

													BgL_bucketz00_2486 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2477), BgL_modz00_2482);
													BgL_res1950z00_2505 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2486), BgL_restz00_2484);
					}}}}}}}}
					BgL_method1178z00_1643 = BgL_res1950z00_2505;
				}
				return
					((BgL_threadz00_bglt)
					(VA_PROCEDUREP(BgL_method1178z00_1643) ? ((obj_t(*)(obj_t,
									...))
							PROCEDURE_ENTRY(BgL_method1178z00_1643)) (BgL_method1178z00_1643,
							((obj_t) BgL_tbz00_7), BgL_bodyz00_8, BgL_namez00_9,
							BEOA) : ((obj_t(*)(obj_t, obj_t, obj_t,
									obj_t))
							PROCEDURE_ENTRY(BgL_method1178z00_1643)) (BgL_method1178z00_1643,
							((obj_t) BgL_tbz00_7), BgL_bodyz00_8, BgL_namez00_9)));
			}
		}

	}



/* &tb-make-thread */
	BgL_threadz00_bglt BGl_z62tbzd2makezd2threadz62zz__threadz00(obj_t
		BgL_envz00_3681, obj_t BgL_tbz00_3682, obj_t BgL_bodyz00_3683,
		obj_t BgL_namez00_3684)
	{
		{	/* Llib/thread.scm 321 */
			{	/* Llib/thread.scm 321 */
				obj_t BgL_auxz00_5746;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5719;

				if (PROCEDUREP(BgL_bodyz00_3683))
					{	/* Llib/thread.scm 321 */
						BgL_auxz00_5746 = BgL_bodyz00_3683;
					}
				else
					{
						obj_t BgL_auxz00_5749;

						BgL_auxz00_5749 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(12558L), BGl_string2322z00zz__threadz00,
							BGl_string2172z00zz__threadz00, BgL_bodyz00_3683);
						FAILURE(BgL_auxz00_5749, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 321 */
					bool_t BgL_test2664z00_5720;

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

						BgL_classz00_4078 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3682))
							{	/* Llib/thread.scm 321 */
								BgL_objectz00_bglt BgL_arg1933z00_4080;
								long BgL_arg1934z00_4081;

								BgL_arg1933z00_4080 = (BgL_objectz00_bglt) (BgL_tbz00_3682);
								BgL_arg1934z00_4081 = BGL_CLASS_DEPTH(BgL_classz00_4078);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 321 */
										long BgL_idxz00_4089;

										BgL_idxz00_4089 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4080);
										{	/* Llib/thread.scm 321 */
											obj_t BgL_arg1925z00_4090;

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

												BgL_arg1926z00_4091 =
													(BgL_idxz00_4089 + BgL_arg1934z00_4081);
												BgL_arg1925z00_4090 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4091);
											}
											BgL_test2664z00_5720 =
												(BgL_arg1925z00_4090 == BgL_classz00_4078);
									}}
								else
									{	/* Llib/thread.scm 321 */
										bool_t BgL_res2043z00_4096;

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

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

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

													BgL_arg1939z00_4103 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4080);
													BgL_arg1938z00_4102 =
														(BgL_arg1939z00_4103 - OBJECT_TYPE);
												}
												BgL_oclassz00_4100 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4102);
											}
											{	/* Llib/thread.scm 321 */
												bool_t BgL__ortest_1147z00_4109;

												BgL__ortest_1147z00_4109 =
													(BgL_classz00_4078 == BgL_oclassz00_4100);
												if (BgL__ortest_1147z00_4109)
													{	/* Llib/thread.scm 321 */
														BgL_res2043z00_4096 = BgL__ortest_1147z00_4109;
													}
												else
													{	/* Llib/thread.scm 321 */
														long BgL_odepthz00_4110;

														BgL_odepthz00_4110 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4100);
														if ((BgL_arg1934z00_4081 < BgL_odepthz00_4110))
															{	/* Llib/thread.scm 321 */
																obj_t BgL_arg1927z00_4114;

																BgL_arg1927z00_4114 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4100,
																	BgL_arg1934z00_4081);
																BgL_res2043z00_4096 =
																	(BgL_arg1927z00_4114 == BgL_classz00_4078);
															}
														else
															{	/* Llib/thread.scm 321 */
																BgL_res2043z00_4096 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2664z00_5720 = BgL_res2043z00_4096;
									}
							}
						else
							{	/* Llib/thread.scm 321 */
								BgL_test2664z00_5720 = ((bool_t) 0);
							}
					}
					if (BgL_test2664z00_5720)
						{	/* Llib/thread.scm 321 */
							BgL_auxz00_5719 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3682);
						}
					else
						{
							obj_t BgL_auxz00_5742;

							BgL_auxz00_5742 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(12558L), BGl_string2322z00zz__threadz00,
								BGl_string2165z00zz__threadz00, BgL_tbz00_3682);
							FAILURE(BgL_auxz00_5742, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2makezd2threadz00zz__threadz00(BgL_auxz00_5719,
					BgL_auxz00_5746, BgL_namez00_3684);
			}
		}

	}



/* 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_1644;

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

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

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

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

								BgL_offsetz00_2511 = (int) (BgL_objzd2classzd2numz00_2507);
								{	/* Llib/thread.scm 326 */
									long BgL_offsetz00_2512;

									BgL_offsetz00_2512 =
										((long) (BgL_offsetz00_2511) - OBJECT_TYPE);
									{	/* Llib/thread.scm 326 */
										long BgL_modz00_2513;

										BgL_modz00_2513 =
											(BgL_offsetz00_2512 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 326 */
											long BgL_restz00_2515;

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

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

													BgL_bucketz00_2517 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2508), BgL_modz00_2513);
													BgL_res1955z00_2536 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2517), BgL_restz00_2515);
					}}}}}}}}
					BgL_method1180z00_1644 = BgL_res1955z00_2536;
				}
				return
					(VA_PROCEDUREP(BgL_method1180z00_1644) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1180z00_1644)) (BgL_method1180z00_1644,
						((obj_t) BgL_tbz00_10), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1180z00_1644)) (BgL_method1180z00_1644,
						((obj_t) BgL_tbz00_10)));
			}
		}

	}



/* &tb-current-thread */
	obj_t BGl_z62tbzd2currentzd2threadz62zz__threadz00(obj_t BgL_envz00_3685,
		obj_t BgL_tbz00_3686)
	{
		{	/* Llib/thread.scm 326 */
			{	/* Llib/thread.scm 326 */
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5784;

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

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

						BgL_classz00_4115 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3686))
							{	/* Llib/thread.scm 326 */
								BgL_objectz00_bglt BgL_arg1933z00_4117;
								long BgL_arg1934z00_4118;

								BgL_arg1933z00_4117 = (BgL_objectz00_bglt) (BgL_tbz00_3686);
								BgL_arg1934z00_4118 = BGL_CLASS_DEPTH(BgL_classz00_4115);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 326 */
										long BgL_idxz00_4126;

										BgL_idxz00_4126 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4117);
										{	/* Llib/thread.scm 326 */
											obj_t BgL_arg1925z00_4127;

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

												BgL_arg1926z00_4128 =
													(BgL_idxz00_4126 + BgL_arg1934z00_4118);
												BgL_arg1925z00_4127 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4128);
											}
											BgL_test2670z00_5785 =
												(BgL_arg1925z00_4127 == BgL_classz00_4115);
									}}
								else
									{	/* Llib/thread.scm 326 */
										bool_t BgL_res2043z00_4133;

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

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

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

													BgL_arg1939z00_4140 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4117);
													BgL_arg1938z00_4139 =
														(BgL_arg1939z00_4140 - OBJECT_TYPE);
												}
												BgL_oclassz00_4137 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4139);
											}
											{	/* Llib/thread.scm 326 */
												bool_t BgL__ortest_1147z00_4146;

												BgL__ortest_1147z00_4146 =
													(BgL_classz00_4115 == BgL_oclassz00_4137);
												if (BgL__ortest_1147z00_4146)
													{	/* Llib/thread.scm 326 */
														BgL_res2043z00_4133 = BgL__ortest_1147z00_4146;
													}
												else
													{	/* Llib/thread.scm 326 */
														long BgL_odepthz00_4147;

														BgL_odepthz00_4147 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4137);
														if ((BgL_arg1934z00_4118 < BgL_odepthz00_4147))
															{	/* Llib/thread.scm 326 */
																obj_t BgL_arg1927z00_4151;

																BgL_arg1927z00_4151 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4137,
																	BgL_arg1934z00_4118);
																BgL_res2043z00_4133 =
																	(BgL_arg1927z00_4151 == BgL_classz00_4115);
															}
														else
															{	/* Llib/thread.scm 326 */
																BgL_res2043z00_4133 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2670z00_5785 = BgL_res2043z00_4133;
									}
							}
						else
							{	/* Llib/thread.scm 326 */
								BgL_test2670z00_5785 = ((bool_t) 0);
							}
					}
					if (BgL_test2670z00_5785)
						{	/* Llib/thread.scm 326 */
							BgL_auxz00_5784 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3686);
						}
					else
						{
							obj_t BgL_auxz00_5807;

							BgL_auxz00_5807 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(12844L), BGl_string2323z00zz__threadz00,
								BGl_string2165z00zz__threadz00, BgL_tbz00_3686);
							FAILURE(BgL_auxz00_5807, BFALSE, BFALSE);
						}
				}
				return BGl_tbzd2currentzd2threadz00zz__threadz00(BgL_auxz00_5784);
			}
		}

	}



/* 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_1645;

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

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

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

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

								BgL_offsetz00_2542 = (int) (BgL_objzd2classzd2numz00_2538);
								{	/* Llib/thread.scm 350 */
									long BgL_offsetz00_2543;

									BgL_offsetz00_2543 =
										((long) (BgL_offsetz00_2542) - OBJECT_TYPE);
									{	/* Llib/thread.scm 350 */
										long BgL_modz00_2544;

										BgL_modz00_2544 =
											(BgL_offsetz00_2543 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 350 */
											long BgL_restz00_2546;

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

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

													BgL_bucketz00_2548 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2539), BgL_modz00_2544);
													BgL_res1960z00_2567 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2548), BgL_restz00_2546);
					}}}}}}}}
					BgL_method1186z00_1645 = BgL_res1960z00_2567;
				}
				return
					(VA_PROCEDUREP(BgL_method1186z00_1645) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1186z00_1645)) (BgL_method1186z00_1645,
						((obj_t) BgL_tbz00_15), BgL_mutexz00_16, BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1186z00_1645)) (BgL_method1186z00_1645,
						((obj_t) BgL_tbz00_15), BgL_mutexz00_16));
			}
		}

	}



/* &tb-mutex-initialize! */
	obj_t BGl_z62tbzd2mutexzd2initializa7ez12zd7zz__threadz00(obj_t
		BgL_envz00_3687, obj_t BgL_tbz00_3688, obj_t BgL_mutexz00_3689)
	{
		{	/* Llib/thread.scm 350 */
			{	/* Llib/thread.scm 350 */
				obj_t BgL_auxz00_5870;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5843;

				if (BGL_MUTEXP(BgL_mutexz00_3689))
					{	/* Llib/thread.scm 350 */
						BgL_auxz00_5870 = BgL_mutexz00_3689;
					}
				else
					{
						obj_t BgL_auxz00_5873;

						BgL_auxz00_5873 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(14029L), BGl_string2324z00zz__threadz00,
							BGl_string2177z00zz__threadz00, BgL_mutexz00_3689);
						FAILURE(BgL_auxz00_5873, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 350 */
					bool_t BgL_test2675z00_5844;

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

						BgL_classz00_4152 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3688))
							{	/* Llib/thread.scm 350 */
								BgL_objectz00_bglt BgL_arg1933z00_4154;
								long BgL_arg1934z00_4155;

								BgL_arg1933z00_4154 = (BgL_objectz00_bglt) (BgL_tbz00_3688);
								BgL_arg1934z00_4155 = BGL_CLASS_DEPTH(BgL_classz00_4152);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 350 */
										long BgL_idxz00_4163;

										BgL_idxz00_4163 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4154);
										{	/* Llib/thread.scm 350 */
											obj_t BgL_arg1925z00_4164;

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

												BgL_arg1926z00_4165 =
													(BgL_idxz00_4163 + BgL_arg1934z00_4155);
												BgL_arg1925z00_4164 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4165);
											}
											BgL_test2675z00_5844 =
												(BgL_arg1925z00_4164 == BgL_classz00_4152);
									}}
								else
									{	/* Llib/thread.scm 350 */
										bool_t BgL_res2043z00_4170;

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

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

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

													BgL_arg1939z00_4177 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4154);
													BgL_arg1938z00_4176 =
														(BgL_arg1939z00_4177 - OBJECT_TYPE);
												}
												BgL_oclassz00_4174 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4176);
											}
											{	/* Llib/thread.scm 350 */
												bool_t BgL__ortest_1147z00_4183;

												BgL__ortest_1147z00_4183 =
													(BgL_classz00_4152 == BgL_oclassz00_4174);
												if (BgL__ortest_1147z00_4183)
													{	/* Llib/thread.scm 350 */
														BgL_res2043z00_4170 = BgL__ortest_1147z00_4183;
													}
												else
													{	/* Llib/thread.scm 350 */
														long BgL_odepthz00_4184;

														BgL_odepthz00_4184 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4174);
														if ((BgL_arg1934z00_4155 < BgL_odepthz00_4184))
															{	/* Llib/thread.scm 350 */
																obj_t BgL_arg1927z00_4188;

																BgL_arg1927z00_4188 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4174,
																	BgL_arg1934z00_4155);
																BgL_res2043z00_4170 =
																	(BgL_arg1927z00_4188 == BgL_classz00_4152);
															}
														else
															{	/* Llib/thread.scm 350 */
																BgL_res2043z00_4170 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2675z00_5844 = BgL_res2043z00_4170;
									}
							}
						else
							{	/* Llib/thread.scm 350 */
								BgL_test2675z00_5844 = ((bool_t) 0);
							}
					}
					if (BgL_test2675z00_5844)
						{	/* Llib/thread.scm 350 */
							BgL_auxz00_5843 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3688);
						}
					else
						{
							obj_t BgL_auxz00_5866;

							BgL_auxz00_5866 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(14029L), BGl_string2324z00zz__threadz00,
								BGl_string2165z00zz__threadz00, BgL_tbz00_3688);
							FAILURE(BgL_auxz00_5866, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2mutexzd2initializa7ez12zb5zz__threadz00(BgL_auxz00_5843,
					BgL_auxz00_5870);
			}
		}

	}



/* 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_1646;

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

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

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

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

								BgL_offsetz00_2573 = (int) (BgL_objzd2classzd2numz00_2569);
								{	/* Llib/thread.scm 355 */
									long BgL_offsetz00_2574;

									BgL_offsetz00_2574 =
										((long) (BgL_offsetz00_2573) - OBJECT_TYPE);
									{	/* Llib/thread.scm 355 */
										long BgL_modz00_2575;

										BgL_modz00_2575 =
											(BgL_offsetz00_2574 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 355 */
											long BgL_restz00_2577;

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

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

													BgL_bucketz00_2579 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2570), BgL_modz00_2575);
													BgL_res1965z00_2598 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2579), BgL_restz00_2577);
					}}}}}}}}
					BgL_method1188z00_1646 = BgL_res1965z00_2598;
				}
				return
					(VA_PROCEDUREP(BgL_method1188z00_1646) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1188z00_1646)) (BgL_method1188z00_1646,
						((obj_t) BgL_tbz00_17), BgL_condvarz00_18, BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1188z00_1646)) (BgL_method1188z00_1646,
						((obj_t) BgL_tbz00_17), BgL_condvarz00_18));
			}
		}

	}



/* &tb-condvar-initialize! */
	obj_t BGl_z62tbzd2condvarzd2initializa7ez12zd7zz__threadz00(obj_t
		BgL_envz00_3690, obj_t BgL_tbz00_3691, obj_t BgL_condvarz00_3692)
	{
		{	/* Llib/thread.scm 355 */
			{	/* Llib/thread.scm 355 */
				obj_t BgL_auxz00_5936;
				BgL_threadzd2backendzd2_bglt BgL_auxz00_5909;

				if (BGL_CONDVARP(BgL_condvarz00_3692))
					{	/* Llib/thread.scm 355 */
						BgL_auxz00_5936 = BgL_condvarz00_3692;
					}
				else
					{
						obj_t BgL_auxz00_5939;

						BgL_auxz00_5939 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(14317L), BGl_string2325z00zz__threadz00,
							BGl_string2190z00zz__threadz00, BgL_condvarz00_3692);
						FAILURE(BgL_auxz00_5939, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 355 */
					bool_t BgL_test2681z00_5910;

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

						BgL_classz00_4189 = BGl_threadzd2backendzd2zz__threadz00;
						if (BGL_OBJECTP(BgL_tbz00_3691))
							{	/* Llib/thread.scm 355 */
								BgL_objectz00_bglt BgL_arg1933z00_4191;
								long BgL_arg1934z00_4192;

								BgL_arg1933z00_4191 = (BgL_objectz00_bglt) (BgL_tbz00_3691);
								BgL_arg1934z00_4192 = BGL_CLASS_DEPTH(BgL_classz00_4189);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 355 */
										long BgL_idxz00_4200;

										BgL_idxz00_4200 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4191);
										{	/* Llib/thread.scm 355 */
											obj_t BgL_arg1925z00_4201;

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

												BgL_arg1926z00_4202 =
													(BgL_idxz00_4200 + BgL_arg1934z00_4192);
												BgL_arg1925z00_4201 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4202);
											}
											BgL_test2681z00_5910 =
												(BgL_arg1925z00_4201 == BgL_classz00_4189);
									}}
								else
									{	/* Llib/thread.scm 355 */
										bool_t BgL_res2043z00_4207;

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

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

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

													BgL_arg1939z00_4214 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4191);
													BgL_arg1938z00_4213 =
														(BgL_arg1939z00_4214 - OBJECT_TYPE);
												}
												BgL_oclassz00_4211 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4213);
											}
											{	/* Llib/thread.scm 355 */
												bool_t BgL__ortest_1147z00_4220;

												BgL__ortest_1147z00_4220 =
													(BgL_classz00_4189 == BgL_oclassz00_4211);
												if (BgL__ortest_1147z00_4220)
													{	/* Llib/thread.scm 355 */
														BgL_res2043z00_4207 = BgL__ortest_1147z00_4220;
													}
												else
													{	/* Llib/thread.scm 355 */
														long BgL_odepthz00_4221;

														BgL_odepthz00_4221 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4211);
														if ((BgL_arg1934z00_4192 < BgL_odepthz00_4221))
															{	/* Llib/thread.scm 355 */
																obj_t BgL_arg1927z00_4225;

																BgL_arg1927z00_4225 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4211,
																	BgL_arg1934z00_4192);
																BgL_res2043z00_4207 =
																	(BgL_arg1927z00_4225 == BgL_classz00_4189);
															}
														else
															{	/* Llib/thread.scm 355 */
																BgL_res2043z00_4207 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2681z00_5910 = BgL_res2043z00_4207;
									}
							}
						else
							{	/* Llib/thread.scm 355 */
								BgL_test2681z00_5910 = ((bool_t) 0);
							}
					}
					if (BgL_test2681z00_5910)
						{	/* Llib/thread.scm 355 */
							BgL_auxz00_5909 = ((BgL_threadzd2backendzd2_bglt) BgL_tbz00_3691);
						}
					else
						{
							obj_t BgL_auxz00_5932;

							BgL_auxz00_5932 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(14317L), BGl_string2325z00zz__threadz00,
								BGl_string2165z00zz__threadz00, BgL_tbz00_3691);
							FAILURE(BgL_auxz00_5932, BFALSE, BFALSE);
						}
				}
				return
					BGl_tbzd2condvarzd2initializa7ez12zb5zz__threadz00(BgL_auxz00_5909,
					BgL_auxz00_5936);
			}
		}

	}



/* 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_method1197z00_1647;

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

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

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

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

								BgL_offsetz00_2604 = (int) (BgL_objzd2classzd2numz00_2600);
								{	/* Llib/thread.scm 384 */
									long BgL_offsetz00_2605;

									BgL_offsetz00_2605 =
										((long) (BgL_offsetz00_2604) - OBJECT_TYPE);
									{	/* Llib/thread.scm 384 */
										long BgL_modz00_2606;

										BgL_modz00_2606 =
											(BgL_offsetz00_2605 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 384 */
											long BgL_restz00_2608;

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

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

													BgL_bucketz00_2610 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2601), BgL_modz00_2606);
													BgL_res1970z00_2629 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2610), BgL_restz00_2608);
					}}}}}}}}
					BgL_method1197z00_1647 = BgL_res1970z00_2629;
				}
				return
					(VA_PROCEDUREP(BgL_method1197z00_1647) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1197z00_1647)) (BgL_method1197z00_1647,
						((obj_t) BgL_thz00_26), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1197z00_1647)) (BgL_method1197z00_1647,
						((obj_t) BgL_thz00_26)));
			}
		}

	}



/* &thread-initialize! */
	obj_t BGl_z62threadzd2initializa7ez12z05zz__threadz00(obj_t BgL_envz00_3611,
		obj_t BgL_thz00_3612)
	{
		{	/* Llib/thread.scm 384 */
			{	/* Llib/thread.scm 384 */
				BgL_threadz00_bglt BgL_auxz00_5974;

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

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

						BgL_classz00_4226 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3612))
							{	/* Llib/thread.scm 384 */
								BgL_objectz00_bglt BgL_arg1933z00_4228;
								long BgL_arg1934z00_4229;

								BgL_arg1933z00_4228 = (BgL_objectz00_bglt) (BgL_thz00_3612);
								BgL_arg1934z00_4229 = BGL_CLASS_DEPTH(BgL_classz00_4226);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 384 */
										long BgL_idxz00_4237;

										BgL_idxz00_4237 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4228);
										{	/* Llib/thread.scm 384 */
											obj_t BgL_arg1925z00_4238;

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

												BgL_arg1926z00_4239 =
													(BgL_idxz00_4237 + BgL_arg1934z00_4229);
												BgL_arg1925z00_4238 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4239);
											}
											BgL_test2687z00_5975 =
												(BgL_arg1925z00_4238 == BgL_classz00_4226);
									}}
								else
									{	/* Llib/thread.scm 384 */
										bool_t BgL_res2043z00_4244;

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

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

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

													BgL_arg1939z00_4251 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4228);
													BgL_arg1938z00_4250 =
														(BgL_arg1939z00_4251 - OBJECT_TYPE);
												}
												BgL_oclassz00_4248 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4250);
											}
											{	/* Llib/thread.scm 384 */
												bool_t BgL__ortest_1147z00_4257;

												BgL__ortest_1147z00_4257 =
													(BgL_classz00_4226 == BgL_oclassz00_4248);
												if (BgL__ortest_1147z00_4257)
													{	/* Llib/thread.scm 384 */
														BgL_res2043z00_4244 = BgL__ortest_1147z00_4257;
													}
												else
													{	/* Llib/thread.scm 384 */
														long BgL_odepthz00_4258;

														BgL_odepthz00_4258 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4248);
														if ((BgL_arg1934z00_4229 < BgL_odepthz00_4258))
															{	/* Llib/thread.scm 384 */
																obj_t BgL_arg1927z00_4262;

																BgL_arg1927z00_4262 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4248,
																	BgL_arg1934z00_4229);
																BgL_res2043z00_4244 =
																	(BgL_arg1927z00_4262 == BgL_classz00_4226);
															}
														else
															{	/* Llib/thread.scm 384 */
																BgL_res2043z00_4244 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2687z00_5975 = BgL_res2043z00_4244;
									}
							}
						else
							{	/* Llib/thread.scm 384 */
								BgL_test2687z00_5975 = ((bool_t) 0);
							}
					}
					if (BgL_test2687z00_5975)
						{	/* Llib/thread.scm 384 */
							BgL_auxz00_5974 = ((BgL_threadz00_bglt) BgL_thz00_3612);
						}
					else
						{
							obj_t BgL_auxz00_5997;

							BgL_auxz00_5997 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(15868L), BGl_string2326z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3612);
							FAILURE(BgL_auxz00_5997, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2initializa7ez12z67zz__threadz00(BgL_auxz00_5974);
			}
		}

	}



/* 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_method1199z00_1648;

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

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

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

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

								BgL_offsetz00_2635 = (int) (BgL_objzd2classzd2numz00_2631);
								{	/* Llib/thread.scm 390 */
									long BgL_offsetz00_2636;

									BgL_offsetz00_2636 =
										((long) (BgL_offsetz00_2635) - OBJECT_TYPE);
									{	/* Llib/thread.scm 390 */
										long BgL_modz00_2637;

										BgL_modz00_2637 =
											(BgL_offsetz00_2636 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 390 */
											long BgL_restz00_2639;

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

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

													BgL_bucketz00_2641 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2632), BgL_modz00_2637);
													BgL_res1975z00_2660 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2641), BgL_restz00_2639);
					}}}}}}}}
					BgL_method1199z00_1648 = BgL_res1975z00_2660;
				}
				{	/* Llib/thread.scm 390 */
					obj_t BgL_auxz00_6027;

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

						BgL_list1519z00_1649 = MAKE_YOUNG_PAIR(BgL_scz00_28, BNIL);
						BgL_auxz00_6027 =
							BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(
							((obj_t) BgL_thz00_27), BgL_list1519z00_1649);
					}
					return apply(BgL_method1199z00_1648, BgL_auxz00_6027);
				}
			}
		}

	}



/* &thread-start! */
	obj_t BGl_z62threadzd2startz12za2zz__threadz00(obj_t BgL_envz00_3693,
		obj_t BgL_thz00_3694, obj_t BgL_scz00_3695)
	{
		{	/* Llib/thread.scm 390 */
			{	/* Llib/thread.scm 390 */
				BgL_threadz00_bglt BgL_auxz00_6032;

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

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

						BgL_classz00_4263 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3694))
							{	/* Llib/thread.scm 390 */
								BgL_objectz00_bglt BgL_arg1933z00_4265;
								long BgL_arg1934z00_4266;

								BgL_arg1933z00_4265 = (BgL_objectz00_bglt) (BgL_thz00_3694);
								BgL_arg1934z00_4266 = BGL_CLASS_DEPTH(BgL_classz00_4263);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 390 */
										long BgL_idxz00_4274;

										BgL_idxz00_4274 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4265);
										{	/* Llib/thread.scm 390 */
											obj_t BgL_arg1925z00_4275;

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

												BgL_arg1926z00_4276 =
													(BgL_idxz00_4274 + BgL_arg1934z00_4266);
												BgL_arg1925z00_4275 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4276);
											}
											BgL_test2692z00_6033 =
												(BgL_arg1925z00_4275 == BgL_classz00_4263);
									}}
								else
									{	/* Llib/thread.scm 390 */
										bool_t BgL_res2043z00_4281;

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

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

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

													BgL_arg1939z00_4288 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4265);
													BgL_arg1938z00_4287 =
														(BgL_arg1939z00_4288 - OBJECT_TYPE);
												}
												BgL_oclassz00_4285 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4287);
											}
											{	/* Llib/thread.scm 390 */
												bool_t BgL__ortest_1147z00_4294;

												BgL__ortest_1147z00_4294 =
													(BgL_classz00_4263 == BgL_oclassz00_4285);
												if (BgL__ortest_1147z00_4294)
													{	/* Llib/thread.scm 390 */
														BgL_res2043z00_4281 = BgL__ortest_1147z00_4294;
													}
												else
													{	/* Llib/thread.scm 390 */
														long BgL_odepthz00_4295;

														BgL_odepthz00_4295 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4285);
														if ((BgL_arg1934z00_4266 < BgL_odepthz00_4295))
															{	/* Llib/thread.scm 390 */
																obj_t BgL_arg1927z00_4299;

																BgL_arg1927z00_4299 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4285,
																	BgL_arg1934z00_4266);
																BgL_res2043z00_4281 =
																	(BgL_arg1927z00_4299 == BgL_classz00_4263);
															}
														else
															{	/* Llib/thread.scm 390 */
																BgL_res2043z00_4281 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2692z00_6033 = BgL_res2043z00_4281;
									}
							}
						else
							{	/* Llib/thread.scm 390 */
								BgL_test2692z00_6033 = ((bool_t) 0);
							}
					}
					if (BgL_test2692z00_6033)
						{	/* Llib/thread.scm 390 */
							BgL_auxz00_6032 = ((BgL_threadz00_bglt) BgL_thz00_3694);
						}
					else
						{
							obj_t BgL_auxz00_6055;

							BgL_auxz00_6055 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(16146L), BGl_string2327z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3694);
							FAILURE(BgL_auxz00_6055, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2startz12zc0zz__threadz00(BgL_auxz00_6032,
					BgL_scz00_3695);
			}
		}

	}



/* 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_method1201z00_1650;

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

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

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

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

								BgL_offsetz00_2666 = (int) (BgL_objzd2classzd2numz00_2662);
								{	/* Llib/thread.scm 395 */
									long BgL_offsetz00_2667;

									BgL_offsetz00_2667 =
										((long) (BgL_offsetz00_2666) - OBJECT_TYPE);
									{	/* Llib/thread.scm 395 */
										long BgL_modz00_2668;

										BgL_modz00_2668 =
											(BgL_offsetz00_2667 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 395 */
											long BgL_restz00_2670;

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

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

													BgL_bucketz00_2672 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2663), BgL_modz00_2668);
													BgL_res1980z00_2691 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2672), BgL_restz00_2670);
					}}}}}}}}
					BgL_method1201z00_1650 = BgL_res1980z00_2691;
				}
				return
					(VA_PROCEDUREP(BgL_method1201z00_1650) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1201z00_1650)) (BgL_method1201z00_1650,
						((obj_t) BgL_thz00_29), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1201z00_1650)) (BgL_method1201z00_1650,
						((obj_t) BgL_thz00_29)));
			}
		}

	}



/* &thread-start-joinable! */
	obj_t BGl_z62threadzd2startzd2joinablez12z70zz__threadz00(obj_t
		BgL_envz00_3696, obj_t BgL_thz00_3697)
	{
		{	/* Llib/thread.scm 395 */
			{	/* Llib/thread.scm 395 */
				BgL_threadz00_bglt BgL_auxz00_6090;

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

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

						BgL_classz00_4300 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3697))
							{	/* Llib/thread.scm 395 */
								BgL_objectz00_bglt BgL_arg1933z00_4302;
								long BgL_arg1934z00_4303;

								BgL_arg1933z00_4302 = (BgL_objectz00_bglt) (BgL_thz00_3697);
								BgL_arg1934z00_4303 = BGL_CLASS_DEPTH(BgL_classz00_4300);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 395 */
										long BgL_idxz00_4311;

										BgL_idxz00_4311 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4302);
										{	/* Llib/thread.scm 395 */
											obj_t BgL_arg1925z00_4312;

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

												BgL_arg1926z00_4313 =
													(BgL_idxz00_4311 + BgL_arg1934z00_4303);
												BgL_arg1925z00_4312 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4313);
											}
											BgL_test2697z00_6091 =
												(BgL_arg1925z00_4312 == BgL_classz00_4300);
									}}
								else
									{	/* Llib/thread.scm 395 */
										bool_t BgL_res2043z00_4318;

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

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

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

													BgL_arg1939z00_4325 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4302);
													BgL_arg1938z00_4324 =
														(BgL_arg1939z00_4325 - OBJECT_TYPE);
												}
												BgL_oclassz00_4322 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4324);
											}
											{	/* Llib/thread.scm 395 */
												bool_t BgL__ortest_1147z00_4331;

												BgL__ortest_1147z00_4331 =
													(BgL_classz00_4300 == BgL_oclassz00_4322);
												if (BgL__ortest_1147z00_4331)
													{	/* Llib/thread.scm 395 */
														BgL_res2043z00_4318 = BgL__ortest_1147z00_4331;
													}
												else
													{	/* Llib/thread.scm 395 */
														long BgL_odepthz00_4332;

														BgL_odepthz00_4332 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4322);
														if ((BgL_arg1934z00_4303 < BgL_odepthz00_4332))
															{	/* Llib/thread.scm 395 */
																obj_t BgL_arg1927z00_4336;

																BgL_arg1927z00_4336 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4322,
																	BgL_arg1934z00_4303);
																BgL_res2043z00_4318 =
																	(BgL_arg1927z00_4336 == BgL_classz00_4300);
															}
														else
															{	/* Llib/thread.scm 395 */
																BgL_res2043z00_4318 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2697z00_6091 = BgL_res2043z00_4318;
									}
							}
						else
							{	/* Llib/thread.scm 395 */
								BgL_test2697z00_6091 = ((bool_t) 0);
							}
					}
					if (BgL_test2697z00_6091)
						{	/* Llib/thread.scm 395 */
							BgL_auxz00_6090 = ((BgL_threadz00_bglt) BgL_thz00_3697);
						}
					else
						{
							obj_t BgL_auxz00_6113;

							BgL_auxz00_6113 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(16418L), BGl_string2328z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3697);
							FAILURE(BgL_auxz00_6113, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2startzd2joinablez12z12zz__threadz00(BgL_auxz00_6090);
			}
		}

	}



/* 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_method1203z00_1651;

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

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

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

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

								BgL_offsetz00_2697 = (int) (BgL_objzd2classzd2numz00_2693);
								{	/* Llib/thread.scm 400 */
									long BgL_offsetz00_2698;

									BgL_offsetz00_2698 =
										((long) (BgL_offsetz00_2697) - OBJECT_TYPE);
									{	/* Llib/thread.scm 400 */
										long BgL_modz00_2699;

										BgL_modz00_2699 =
											(BgL_offsetz00_2698 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 400 */
											long BgL_restz00_2701;

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

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

													BgL_bucketz00_2703 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2694), BgL_modz00_2699);
													BgL_res1985z00_2722 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2703), BgL_restz00_2701);
					}}}}}}}}
					BgL_method1203z00_1651 = BgL_res1985z00_2722;
				}
				{	/* Llib/thread.scm 400 */
					obj_t BgL_auxz00_6143;

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

						BgL_list1520z00_1652 = MAKE_YOUNG_PAIR(BgL_timeoutz00_31, BNIL);
						BgL_auxz00_6143 =
							BGl_consza2za2zz__r4_pairs_and_lists_6_3z00(
							((obj_t) BgL_thz00_30), BgL_list1520z00_1652);
					}
					return apply(BgL_method1203z00_1651, BgL_auxz00_6143);
				}
			}
		}

	}



/* &thread-join! */
	obj_t BGl_z62threadzd2joinz12za2zz__threadz00(obj_t BgL_envz00_3698,
		obj_t BgL_thz00_3699, obj_t BgL_timeoutz00_3700)
	{
		{	/* Llib/thread.scm 400 */
			{	/* Llib/thread.scm 400 */
				BgL_threadz00_bglt BgL_auxz00_6148;

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

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

						BgL_classz00_4337 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3699))
							{	/* Llib/thread.scm 400 */
								BgL_objectz00_bglt BgL_arg1933z00_4339;
								long BgL_arg1934z00_4340;

								BgL_arg1933z00_4339 = (BgL_objectz00_bglt) (BgL_thz00_3699);
								BgL_arg1934z00_4340 = BGL_CLASS_DEPTH(BgL_classz00_4337);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 400 */
										long BgL_idxz00_4348;

										BgL_idxz00_4348 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4339);
										{	/* Llib/thread.scm 400 */
											obj_t BgL_arg1925z00_4349;

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

												BgL_arg1926z00_4350 =
													(BgL_idxz00_4348 + BgL_arg1934z00_4340);
												BgL_arg1925z00_4349 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4350);
											}
											BgL_test2702z00_6149 =
												(BgL_arg1925z00_4349 == BgL_classz00_4337);
									}}
								else
									{	/* Llib/thread.scm 400 */
										bool_t BgL_res2043z00_4355;

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

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

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

													BgL_arg1939z00_4362 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4339);
													BgL_arg1938z00_4361 =
														(BgL_arg1939z00_4362 - OBJECT_TYPE);
												}
												BgL_oclassz00_4359 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4361);
											}
											{	/* Llib/thread.scm 400 */
												bool_t BgL__ortest_1147z00_4368;

												BgL__ortest_1147z00_4368 =
													(BgL_classz00_4337 == BgL_oclassz00_4359);
												if (BgL__ortest_1147z00_4368)
													{	/* Llib/thread.scm 400 */
														BgL_res2043z00_4355 = BgL__ortest_1147z00_4368;
													}
												else
													{	/* Llib/thread.scm 400 */
														long BgL_odepthz00_4369;

														BgL_odepthz00_4369 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4359);
														if ((BgL_arg1934z00_4340 < BgL_odepthz00_4369))
															{	/* Llib/thread.scm 400 */
																obj_t BgL_arg1927z00_4373;

																BgL_arg1927z00_4373 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4359,
																	BgL_arg1934z00_4340);
																BgL_res2043z00_4355 =
																	(BgL_arg1927z00_4373 == BgL_classz00_4337);
															}
														else
															{	/* Llib/thread.scm 400 */
																BgL_res2043z00_4355 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2702z00_6149 = BgL_res2043z00_4355;
									}
							}
						else
							{	/* Llib/thread.scm 400 */
								BgL_test2702z00_6149 = ((bool_t) 0);
							}
					}
					if (BgL_test2702z00_6149)
						{	/* Llib/thread.scm 400 */
							BgL_auxz00_6148 = ((BgL_threadz00_bglt) BgL_thz00_3699);
						}
					else
						{
							obj_t BgL_auxz00_6171;

							BgL_auxz00_6171 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(16694L), BGl_string2329z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3699);
							FAILURE(BgL_auxz00_6171, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2joinz12zc0zz__threadz00(BgL_auxz00_6148,
					BgL_timeoutz00_3700);
			}
		}

	}



/* 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_method1205z00_1653;

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

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

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

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

								BgL_offsetz00_2728 = (int) (BgL_objzd2classzd2numz00_2724);
								{	/* Llib/thread.scm 405 */
									long BgL_offsetz00_2729;

									BgL_offsetz00_2729 =
										((long) (BgL_offsetz00_2728) - OBJECT_TYPE);
									{	/* Llib/thread.scm 405 */
										long BgL_modz00_2730;

										BgL_modz00_2730 =
											(BgL_offsetz00_2729 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 405 */
											long BgL_restz00_2732;

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

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

													BgL_bucketz00_2734 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2725), BgL_modz00_2730);
													BgL_res1990z00_2753 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2734), BgL_restz00_2732);
					}}}}}}}}
					BgL_method1205z00_1653 = BgL_res1990z00_2753;
				}
				return
					(VA_PROCEDUREP(BgL_method1205z00_1653) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1205z00_1653)) (BgL_method1205z00_1653,
						((obj_t) BgL_thz00_32), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1205z00_1653)) (BgL_method1205z00_1653,
						((obj_t) BgL_thz00_32)));
			}
		}

	}



/* &thread-terminate! */
	obj_t BGl_z62threadzd2terminatez12za2zz__threadz00(obj_t BgL_envz00_3701,
		obj_t BgL_thz00_3702)
	{
		{	/* Llib/thread.scm 405 */
			{	/* Llib/thread.scm 405 */
				BgL_threadz00_bglt BgL_auxz00_6206;

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

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

						BgL_classz00_4374 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3702))
							{	/* Llib/thread.scm 405 */
								BgL_objectz00_bglt BgL_arg1933z00_4376;
								long BgL_arg1934z00_4377;

								BgL_arg1933z00_4376 = (BgL_objectz00_bglt) (BgL_thz00_3702);
								BgL_arg1934z00_4377 = BGL_CLASS_DEPTH(BgL_classz00_4374);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 405 */
										long BgL_idxz00_4385;

										BgL_idxz00_4385 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4376);
										{	/* Llib/thread.scm 405 */
											obj_t BgL_arg1925z00_4386;

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

												BgL_arg1926z00_4387 =
													(BgL_idxz00_4385 + BgL_arg1934z00_4377);
												BgL_arg1925z00_4386 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4387);
											}
											BgL_test2707z00_6207 =
												(BgL_arg1925z00_4386 == BgL_classz00_4374);
									}}
								else
									{	/* Llib/thread.scm 405 */
										bool_t BgL_res2043z00_4392;

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

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

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

													BgL_arg1939z00_4399 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4376);
													BgL_arg1938z00_4398 =
														(BgL_arg1939z00_4399 - OBJECT_TYPE);
												}
												BgL_oclassz00_4396 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4398);
											}
											{	/* Llib/thread.scm 405 */
												bool_t BgL__ortest_1147z00_4405;

												BgL__ortest_1147z00_4405 =
													(BgL_classz00_4374 == BgL_oclassz00_4396);
												if (BgL__ortest_1147z00_4405)
													{	/* Llib/thread.scm 405 */
														BgL_res2043z00_4392 = BgL__ortest_1147z00_4405;
													}
												else
													{	/* Llib/thread.scm 405 */
														long BgL_odepthz00_4406;

														BgL_odepthz00_4406 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4396);
														if ((BgL_arg1934z00_4377 < BgL_odepthz00_4406))
															{	/* Llib/thread.scm 405 */
																obj_t BgL_arg1927z00_4410;

																BgL_arg1927z00_4410 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4396,
																	BgL_arg1934z00_4377);
																BgL_res2043z00_4392 =
																	(BgL_arg1927z00_4410 == BgL_classz00_4374);
															}
														else
															{	/* Llib/thread.scm 405 */
																BgL_res2043z00_4392 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2707z00_6207 = BgL_res2043z00_4392;
									}
							}
						else
							{	/* Llib/thread.scm 405 */
								BgL_test2707z00_6207 = ((bool_t) 0);
							}
					}
					if (BgL_test2707z00_6207)
						{	/* Llib/thread.scm 405 */
							BgL_auxz00_6206 = ((BgL_threadz00_bglt) BgL_thz00_3702);
						}
					else
						{
							obj_t BgL_auxz00_6229;

							BgL_auxz00_6229 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(16970L), BGl_string2330z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3702);
							FAILURE(BgL_auxz00_6229, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2terminatez12zc0zz__threadz00(BgL_auxz00_6206);
			}
		}

	}



/* 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_method1207z00_1654;

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

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

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

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

								BgL_offsetz00_2759 = (int) (BgL_objzd2classzd2numz00_2755);
								{	/* Llib/thread.scm 410 */
									long BgL_offsetz00_2760;

									BgL_offsetz00_2760 =
										((long) (BgL_offsetz00_2759) - OBJECT_TYPE);
									{	/* Llib/thread.scm 410 */
										long BgL_modz00_2761;

										BgL_modz00_2761 =
											(BgL_offsetz00_2760 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 410 */
											long BgL_restz00_2763;

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

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

													BgL_bucketz00_2765 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2756), BgL_modz00_2761);
													BgL_res1995z00_2784 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2765), BgL_restz00_2763);
					}}}}}}}}
					BgL_method1207z00_1654 = BgL_res1995z00_2784;
				}
				return
					(VA_PROCEDUREP(BgL_method1207z00_1654) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1207z00_1654)) (BgL_method1207z00_1654,
						((obj_t) BgL_thz00_33), BINT(BgL_nz00_34), BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1207z00_1654)) (BgL_method1207z00_1654,
						((obj_t) BgL_thz00_33), BINT(BgL_nz00_34)));
			}
		}

	}



/* &thread-kill! */
	obj_t BGl_z62threadzd2killz12za2zz__threadz00(obj_t BgL_envz00_3703,
		obj_t BgL_thz00_3704, obj_t BgL_nz00_3705)
	{
		{	/* Llib/thread.scm 410 */
			{	/* Llib/thread.scm 410 */
				int BgL_auxz00_6293;
				BgL_threadz00_bglt BgL_auxz00_6266;

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

					if (INTEGERP(BgL_nz00_3705))
						{	/* Llib/thread.scm 410 */
							BgL_tmpz00_6294 = BgL_nz00_3705;
						}
					else
						{
							obj_t BgL_auxz00_6297;

							BgL_auxz00_6297 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(17241L), BGl_string2331z00zz__threadz00,
								BGl_string2182z00zz__threadz00, BgL_nz00_3705);
							FAILURE(BgL_auxz00_6297, BFALSE, BFALSE);
						}
					BgL_auxz00_6293 = CINT(BgL_tmpz00_6294);
				}
				{	/* Llib/thread.scm 410 */
					bool_t BgL_test2712z00_6267;

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

						BgL_classz00_4411 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3704))
							{	/* Llib/thread.scm 410 */
								BgL_objectz00_bglt BgL_arg1933z00_4413;
								long BgL_arg1934z00_4414;

								BgL_arg1933z00_4413 = (BgL_objectz00_bglt) (BgL_thz00_3704);
								BgL_arg1934z00_4414 = BGL_CLASS_DEPTH(BgL_classz00_4411);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 410 */
										long BgL_idxz00_4422;

										BgL_idxz00_4422 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4413);
										{	/* Llib/thread.scm 410 */
											obj_t BgL_arg1925z00_4423;

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

												BgL_arg1926z00_4424 =
													(BgL_idxz00_4422 + BgL_arg1934z00_4414);
												BgL_arg1925z00_4423 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4424);
											}
											BgL_test2712z00_6267 =
												(BgL_arg1925z00_4423 == BgL_classz00_4411);
									}}
								else
									{	/* Llib/thread.scm 410 */
										bool_t BgL_res2043z00_4429;

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

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

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

													BgL_arg1939z00_4436 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4413);
													BgL_arg1938z00_4435 =
														(BgL_arg1939z00_4436 - OBJECT_TYPE);
												}
												BgL_oclassz00_4433 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4435);
											}
											{	/* Llib/thread.scm 410 */
												bool_t BgL__ortest_1147z00_4442;

												BgL__ortest_1147z00_4442 =
													(BgL_classz00_4411 == BgL_oclassz00_4433);
												if (BgL__ortest_1147z00_4442)
													{	/* Llib/thread.scm 410 */
														BgL_res2043z00_4429 = BgL__ortest_1147z00_4442;
													}
												else
													{	/* Llib/thread.scm 410 */
														long BgL_odepthz00_4443;

														BgL_odepthz00_4443 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4433);
														if ((BgL_arg1934z00_4414 < BgL_odepthz00_4443))
															{	/* Llib/thread.scm 410 */
																obj_t BgL_arg1927z00_4447;

																BgL_arg1927z00_4447 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4433,
																	BgL_arg1934z00_4414);
																BgL_res2043z00_4429 =
																	(BgL_arg1927z00_4447 == BgL_classz00_4411);
															}
														else
															{	/* Llib/thread.scm 410 */
																BgL_res2043z00_4429 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2712z00_6267 = BgL_res2043z00_4429;
									}
							}
						else
							{	/* Llib/thread.scm 410 */
								BgL_test2712z00_6267 = ((bool_t) 0);
							}
					}
					if (BgL_test2712z00_6267)
						{	/* Llib/thread.scm 410 */
							BgL_auxz00_6266 = ((BgL_threadz00_bglt) BgL_thz00_3704);
						}
					else
						{
							obj_t BgL_auxz00_6289;

							BgL_auxz00_6289 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(17241L), BGl_string2331z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3704);
							FAILURE(BgL_auxz00_6289, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2killz12zc0zz__threadz00(BgL_auxz00_6266,
					BgL_auxz00_6293);
			}
		}

	}



/* 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_1655;

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

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

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

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

								BgL_offsetz00_2790 = (int) (BgL_objzd2classzd2numz00_2786);
								{	/* Llib/thread.scm 415 */
									long BgL_offsetz00_2791;

									BgL_offsetz00_2791 =
										((long) (BgL_offsetz00_2790) - OBJECT_TYPE);
									{	/* Llib/thread.scm 415 */
										long BgL_modz00_2792;

										BgL_modz00_2792 =
											(BgL_offsetz00_2791 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 415 */
											long BgL_restz00_2794;

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

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

													BgL_bucketz00_2796 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2787), BgL_modz00_2792);
													BgL_res2000z00_2815 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2796), BgL_restz00_2794);
					}}}}}}}}
					BgL_method1209z00_1655 = BgL_res2000z00_2815;
				}
				return
					(VA_PROCEDUREP(BgL_method1209z00_1655) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1209z00_1655)) (BgL_method1209z00_1655,
						((obj_t) BgL_thz00_35), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1209z00_1655)) (BgL_method1209z00_1655,
						((obj_t) BgL_thz00_35)));
			}
		}

	}



/* &thread-specific */
	obj_t BGl_z62threadzd2specificzb0zz__threadz00(obj_t BgL_envz00_3706,
		obj_t BgL_thz00_3707)
	{
		{	/* Llib/thread.scm 415 */
			{	/* Llib/thread.scm 415 */
				BgL_threadz00_bglt BgL_auxz00_6333;

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

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

						BgL_classz00_4448 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3707))
							{	/* Llib/thread.scm 415 */
								BgL_objectz00_bglt BgL_arg1933z00_4450;
								long BgL_arg1934z00_4451;

								BgL_arg1933z00_4450 = (BgL_objectz00_bglt) (BgL_thz00_3707);
								BgL_arg1934z00_4451 = BGL_CLASS_DEPTH(BgL_classz00_4448);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 415 */
										long BgL_idxz00_4459;

										BgL_idxz00_4459 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4450);
										{	/* Llib/thread.scm 415 */
											obj_t BgL_arg1925z00_4460;

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

												BgL_arg1926z00_4461 =
													(BgL_idxz00_4459 + BgL_arg1934z00_4451);
												BgL_arg1925z00_4460 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4461);
											}
											BgL_test2718z00_6334 =
												(BgL_arg1925z00_4460 == BgL_classz00_4448);
									}}
								else
									{	/* Llib/thread.scm 415 */
										bool_t BgL_res2043z00_4466;

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

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

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

													BgL_arg1939z00_4473 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4450);
													BgL_arg1938z00_4472 =
														(BgL_arg1939z00_4473 - OBJECT_TYPE);
												}
												BgL_oclassz00_4470 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4472);
											}
											{	/* Llib/thread.scm 415 */
												bool_t BgL__ortest_1147z00_4479;

												BgL__ortest_1147z00_4479 =
													(BgL_classz00_4448 == BgL_oclassz00_4470);
												if (BgL__ortest_1147z00_4479)
													{	/* Llib/thread.scm 415 */
														BgL_res2043z00_4466 = BgL__ortest_1147z00_4479;
													}
												else
													{	/* Llib/thread.scm 415 */
														long BgL_odepthz00_4480;

														BgL_odepthz00_4480 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4470);
														if ((BgL_arg1934z00_4451 < BgL_odepthz00_4480))
															{	/* Llib/thread.scm 415 */
																obj_t BgL_arg1927z00_4484;

																BgL_arg1927z00_4484 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4470,
																	BgL_arg1934z00_4451);
																BgL_res2043z00_4466 =
																	(BgL_arg1927z00_4484 == BgL_classz00_4448);
															}
														else
															{	/* Llib/thread.scm 415 */
																BgL_res2043z00_4466 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2718z00_6334 = BgL_res2043z00_4466;
									}
							}
						else
							{	/* Llib/thread.scm 415 */
								BgL_test2718z00_6334 = ((bool_t) 0);
							}
					}
					if (BgL_test2718z00_6334)
						{	/* Llib/thread.scm 415 */
							BgL_auxz00_6333 = ((BgL_threadz00_bglt) BgL_thz00_3707);
						}
					else
						{
							obj_t BgL_auxz00_6356;

							BgL_auxz00_6356 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(17514L), BGl_string2332z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3707);
							FAILURE(BgL_auxz00_6356, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2specificzd2zz__threadz00(BgL_auxz00_6333);
			}
		}

	}



/* 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_method1212z00_1656;

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

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

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

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

								BgL_offsetz00_2821 = (int) (BgL_objzd2classzd2numz00_2817);
								{	/* Llib/thread.scm 420 */
									long BgL_offsetz00_2822;

									BgL_offsetz00_2822 =
										((long) (BgL_offsetz00_2821) - OBJECT_TYPE);
									{	/* Llib/thread.scm 420 */
										long BgL_modz00_2823;

										BgL_modz00_2823 =
											(BgL_offsetz00_2822 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 420 */
											long BgL_restz00_2825;

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

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

													BgL_bucketz00_2827 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2818), BgL_modz00_2823);
													BgL_res2005z00_2846 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2827), BgL_restz00_2825);
					}}}}}}}}
					BgL_method1212z00_1656 = BgL_res2005z00_2846;
				}
				return
					(VA_PROCEDUREP(BgL_method1212z00_1656) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1212z00_1656)) (BgL_method1212z00_1656,
						((obj_t) BgL_thz00_36), BgL_vz00_37, BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1212z00_1656)) (BgL_method1212z00_1656,
						((obj_t) BgL_thz00_36), BgL_vz00_37));
			}
		}

	}



/* &thread-specific-set! */
	obj_t BGl_z62threadzd2specificzd2setz12z70zz__threadz00(obj_t BgL_envz00_3708,
		obj_t BgL_thz00_3709, obj_t BgL_vz00_3710)
	{
		{	/* Llib/thread.scm 420 */
			{	/* Llib/thread.scm 420 */
				BgL_threadz00_bglt BgL_auxz00_6392;

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

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

						BgL_classz00_4485 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3709))
							{	/* Llib/thread.scm 420 */
								BgL_objectz00_bglt BgL_arg1933z00_4487;
								long BgL_arg1934z00_4488;

								BgL_arg1933z00_4487 = (BgL_objectz00_bglt) (BgL_thz00_3709);
								BgL_arg1934z00_4488 = BGL_CLASS_DEPTH(BgL_classz00_4485);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 420 */
										long BgL_idxz00_4496;

										BgL_idxz00_4496 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4487);
										{	/* Llib/thread.scm 420 */
											obj_t BgL_arg1925z00_4497;

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

												BgL_arg1926z00_4498 =
													(BgL_idxz00_4496 + BgL_arg1934z00_4488);
												BgL_arg1925z00_4497 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4498);
											}
											BgL_test2723z00_6393 =
												(BgL_arg1925z00_4497 == BgL_classz00_4485);
									}}
								else
									{	/* Llib/thread.scm 420 */
										bool_t BgL_res2043z00_4503;

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

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

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

													BgL_arg1939z00_4510 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4487);
													BgL_arg1938z00_4509 =
														(BgL_arg1939z00_4510 - OBJECT_TYPE);
												}
												BgL_oclassz00_4507 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4509);
											}
											{	/* Llib/thread.scm 420 */
												bool_t BgL__ortest_1147z00_4516;

												BgL__ortest_1147z00_4516 =
													(BgL_classz00_4485 == BgL_oclassz00_4507);
												if (BgL__ortest_1147z00_4516)
													{	/* Llib/thread.scm 420 */
														BgL_res2043z00_4503 = BgL__ortest_1147z00_4516;
													}
												else
													{	/* Llib/thread.scm 420 */
														long BgL_odepthz00_4517;

														BgL_odepthz00_4517 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4507);
														if ((BgL_arg1934z00_4488 < BgL_odepthz00_4517))
															{	/* Llib/thread.scm 420 */
																obj_t BgL_arg1927z00_4521;

																BgL_arg1927z00_4521 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4507,
																	BgL_arg1934z00_4488);
																BgL_res2043z00_4503 =
																	(BgL_arg1927z00_4521 == BgL_classz00_4485);
															}
														else
															{	/* Llib/thread.scm 420 */
																BgL_res2043z00_4503 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2723z00_6393 = BgL_res2043z00_4503;
									}
							}
						else
							{	/* Llib/thread.scm 420 */
								BgL_test2723z00_6393 = ((bool_t) 0);
							}
					}
					if (BgL_test2723z00_6393)
						{	/* Llib/thread.scm 420 */
							BgL_auxz00_6392 = ((BgL_threadz00_bglt) BgL_thz00_3709);
						}
					else
						{
							obj_t BgL_auxz00_6415;

							BgL_auxz00_6415 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(17783L), BGl_string2333z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3709);
							FAILURE(BgL_auxz00_6415, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2specificzd2setz12z12zz__threadz00(BgL_auxz00_6392,
					BgL_vz00_3710);
			}
		}

	}



/* 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_method1214z00_1657;

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

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

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

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

								BgL_offsetz00_2852 = (int) (BgL_objzd2classzd2numz00_2848);
								{	/* Llib/thread.scm 425 */
									long BgL_offsetz00_2853;

									BgL_offsetz00_2853 =
										((long) (BgL_offsetz00_2852) - OBJECT_TYPE);
									{	/* Llib/thread.scm 425 */
										long BgL_modz00_2854;

										BgL_modz00_2854 =
											(BgL_offsetz00_2853 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 425 */
											long BgL_restz00_2856;

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

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

													BgL_bucketz00_2858 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2849), BgL_modz00_2854);
													BgL_res2010z00_2877 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2858), BgL_restz00_2856);
					}}}}}}}}
					BgL_method1214z00_1657 = BgL_res2010z00_2877;
				}
				return
					(VA_PROCEDUREP(BgL_method1214z00_1657) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1214z00_1657)) (BgL_method1214z00_1657,
						((obj_t) BgL_thz00_38), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1214z00_1657)) (BgL_method1214z00_1657,
						((obj_t) BgL_thz00_38)));
			}
		}

	}



/* &thread-cleanup */
	obj_t BGl_z62threadzd2cleanupzb0zz__threadz00(obj_t BgL_envz00_3711,
		obj_t BgL_thz00_3712)
	{
		{	/* Llib/thread.scm 425 */
			{	/* Llib/thread.scm 425 */
				BgL_threadz00_bglt BgL_auxz00_6450;

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

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

						BgL_classz00_4522 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3712))
							{	/* Llib/thread.scm 425 */
								BgL_objectz00_bglt BgL_arg1933z00_4524;
								long BgL_arg1934z00_4525;

								BgL_arg1933z00_4524 = (BgL_objectz00_bglt) (BgL_thz00_3712);
								BgL_arg1934z00_4525 = BGL_CLASS_DEPTH(BgL_classz00_4522);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 425 */
										long BgL_idxz00_4533;

										BgL_idxz00_4533 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4524);
										{	/* Llib/thread.scm 425 */
											obj_t BgL_arg1925z00_4534;

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

												BgL_arg1926z00_4535 =
													(BgL_idxz00_4533 + BgL_arg1934z00_4525);
												BgL_arg1925z00_4534 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4535);
											}
											BgL_test2728z00_6451 =
												(BgL_arg1925z00_4534 == BgL_classz00_4522);
									}}
								else
									{	/* Llib/thread.scm 425 */
										bool_t BgL_res2043z00_4540;

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

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

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

													BgL_arg1939z00_4547 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4524);
													BgL_arg1938z00_4546 =
														(BgL_arg1939z00_4547 - OBJECT_TYPE);
												}
												BgL_oclassz00_4544 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4546);
											}
											{	/* Llib/thread.scm 425 */
												bool_t BgL__ortest_1147z00_4553;

												BgL__ortest_1147z00_4553 =
													(BgL_classz00_4522 == BgL_oclassz00_4544);
												if (BgL__ortest_1147z00_4553)
													{	/* Llib/thread.scm 425 */
														BgL_res2043z00_4540 = BgL__ortest_1147z00_4553;
													}
												else
													{	/* Llib/thread.scm 425 */
														long BgL_odepthz00_4554;

														BgL_odepthz00_4554 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4544);
														if ((BgL_arg1934z00_4525 < BgL_odepthz00_4554))
															{	/* Llib/thread.scm 425 */
																obj_t BgL_arg1927z00_4558;

																BgL_arg1927z00_4558 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4544,
																	BgL_arg1934z00_4525);
																BgL_res2043z00_4540 =
																	(BgL_arg1927z00_4558 == BgL_classz00_4522);
															}
														else
															{	/* Llib/thread.scm 425 */
																BgL_res2043z00_4540 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2728z00_6451 = BgL_res2043z00_4540;
									}
							}
						else
							{	/* Llib/thread.scm 425 */
								BgL_test2728z00_6451 = ((bool_t) 0);
							}
					}
					if (BgL_test2728z00_6451)
						{	/* Llib/thread.scm 425 */
							BgL_auxz00_6450 = ((BgL_threadz00_bglt) BgL_thz00_3712);
						}
					else
						{
							obj_t BgL_auxz00_6473;

							BgL_auxz00_6473 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(18064L), BGl_string2334z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3712);
							FAILURE(BgL_auxz00_6473, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2cleanupzd2zz__threadz00(BgL_auxz00_6450);
			}
		}

	}



/* 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_method1216z00_1658;

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

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

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

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

								BgL_offsetz00_2883 = (int) (BgL_objzd2classzd2numz00_2879);
								{	/* Llib/thread.scm 430 */
									long BgL_offsetz00_2884;

									BgL_offsetz00_2884 =
										((long) (BgL_offsetz00_2883) - OBJECT_TYPE);
									{	/* Llib/thread.scm 430 */
										long BgL_modz00_2885;

										BgL_modz00_2885 =
											(BgL_offsetz00_2884 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 430 */
											long BgL_restz00_2887;

											BgL_restz00_2887 =
												(BgL_offsetz00_2884 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 430 */

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

													BgL_bucketz00_2889 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2880), BgL_modz00_2885);
													BgL_res2015z00_2908 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2889), BgL_restz00_2887);
					}}}}}}}}
					BgL_method1216z00_1658 = BgL_res2015z00_2908;
				}
				return
					(VA_PROCEDUREP(BgL_method1216z00_1658) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1216z00_1658)) (BgL_method1216z00_1658,
						((obj_t) BgL_thz00_39), BgL_vz00_40, BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1216z00_1658)) (BgL_method1216z00_1658,
						((obj_t) BgL_thz00_39), BgL_vz00_40));
			}
		}

	}



/* &thread-cleanup-set! */
	obj_t BGl_z62threadzd2cleanupzd2setz12z70zz__threadz00(obj_t BgL_envz00_3713,
		obj_t BgL_thz00_3714, obj_t BgL_vz00_3715)
	{
		{	/* Llib/thread.scm 430 */
			{	/* Llib/thread.scm 430 */
				BgL_threadz00_bglt BgL_auxz00_6509;

				{	/* Llib/thread.scm 430 */
					bool_t BgL_test2733z00_6510;

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

						BgL_classz00_4559 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3714))
							{	/* Llib/thread.scm 430 */
								BgL_objectz00_bglt BgL_arg1933z00_4561;
								long BgL_arg1934z00_4562;

								BgL_arg1933z00_4561 = (BgL_objectz00_bglt) (BgL_thz00_3714);
								BgL_arg1934z00_4562 = BGL_CLASS_DEPTH(BgL_classz00_4559);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 430 */
										long BgL_idxz00_4570;

										BgL_idxz00_4570 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4561);
										{	/* Llib/thread.scm 430 */
											obj_t BgL_arg1925z00_4571;

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

												BgL_arg1926z00_4572 =
													(BgL_idxz00_4570 + BgL_arg1934z00_4562);
												BgL_arg1925z00_4571 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4572);
											}
											BgL_test2733z00_6510 =
												(BgL_arg1925z00_4571 == BgL_classz00_4559);
									}}
								else
									{	/* Llib/thread.scm 430 */
										bool_t BgL_res2043z00_4577;

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

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

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

													BgL_arg1939z00_4584 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4561);
													BgL_arg1938z00_4583 =
														(BgL_arg1939z00_4584 - OBJECT_TYPE);
												}
												BgL_oclassz00_4581 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4583);
											}
											{	/* Llib/thread.scm 430 */
												bool_t BgL__ortest_1147z00_4590;

												BgL__ortest_1147z00_4590 =
													(BgL_classz00_4559 == BgL_oclassz00_4581);
												if (BgL__ortest_1147z00_4590)
													{	/* Llib/thread.scm 430 */
														BgL_res2043z00_4577 = BgL__ortest_1147z00_4590;
													}
												else
													{	/* Llib/thread.scm 430 */
														long BgL_odepthz00_4591;

														BgL_odepthz00_4591 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4581);
														if ((BgL_arg1934z00_4562 < BgL_odepthz00_4591))
															{	/* Llib/thread.scm 430 */
																obj_t BgL_arg1927z00_4595;

																BgL_arg1927z00_4595 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4581,
																	BgL_arg1934z00_4562);
																BgL_res2043z00_4577 =
																	(BgL_arg1927z00_4595 == BgL_classz00_4559);
															}
														else
															{	/* Llib/thread.scm 430 */
																BgL_res2043z00_4577 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2733z00_6510 = BgL_res2043z00_4577;
									}
							}
						else
							{	/* Llib/thread.scm 430 */
								BgL_test2733z00_6510 = ((bool_t) 0);
							}
					}
					if (BgL_test2733z00_6510)
						{	/* Llib/thread.scm 430 */
							BgL_auxz00_6509 = ((BgL_threadz00_bglt) BgL_thz00_3714);
						}
					else
						{
							obj_t BgL_auxz00_6532;

							BgL_auxz00_6532 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(18332L), BGl_string2335z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3714);
							FAILURE(BgL_auxz00_6532, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2cleanupzd2setz12z12zz__threadz00(BgL_auxz00_6509,
					BgL_vz00_3715);
			}
		}

	}



/* 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_method1218z00_1659;

				{	/* Llib/thread.scm 435 */
					obj_t BgL_res2020z00_2939;

					{	/* Llib/thread.scm 435 */
						long BgL_objzd2classzd2numz00_2910;

						BgL_objzd2classzd2numz00_2910 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_41));
						{	/* Llib/thread.scm 435 */
							obj_t BgL_arg1935z00_2911;

							BgL_arg1935z00_2911 =
								PROCEDURE_REF(BGl_threadzd2namezd2envz00zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 435 */
								int BgL_offsetz00_2914;

								BgL_offsetz00_2914 = (int) (BgL_objzd2classzd2numz00_2910);
								{	/* Llib/thread.scm 435 */
									long BgL_offsetz00_2915;

									BgL_offsetz00_2915 =
										((long) (BgL_offsetz00_2914) - OBJECT_TYPE);
									{	/* Llib/thread.scm 435 */
										long BgL_modz00_2916;

										BgL_modz00_2916 =
											(BgL_offsetz00_2915 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 435 */
											long BgL_restz00_2918;

											BgL_restz00_2918 =
												(BgL_offsetz00_2915 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 435 */

												{	/* Llib/thread.scm 435 */
													obj_t BgL_bucketz00_2920;

													BgL_bucketz00_2920 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2911), BgL_modz00_2916);
													BgL_res2020z00_2939 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2920), BgL_restz00_2918);
					}}}}}}}}
					BgL_method1218z00_1659 = BgL_res2020z00_2939;
				}
				return
					(VA_PROCEDUREP(BgL_method1218z00_1659) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1218z00_1659)) (BgL_method1218z00_1659,
						((obj_t) BgL_thz00_41), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1218z00_1659)) (BgL_method1218z00_1659,
						((obj_t) BgL_thz00_41)));
			}
		}

	}



/* &thread-name */
	obj_t BGl_z62threadzd2namezb0zz__threadz00(obj_t BgL_envz00_3716,
		obj_t BgL_thz00_3717)
	{
		{	/* Llib/thread.scm 435 */
			{	/* Llib/thread.scm 435 */
				BgL_threadz00_bglt BgL_auxz00_6567;

				{	/* Llib/thread.scm 435 */
					bool_t BgL_test2738z00_6568;

					{	/* Llib/thread.scm 435 */
						obj_t BgL_classz00_4596;

						BgL_classz00_4596 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3717))
							{	/* Llib/thread.scm 435 */
								BgL_objectz00_bglt BgL_arg1933z00_4598;
								long BgL_arg1934z00_4599;

								BgL_arg1933z00_4598 = (BgL_objectz00_bglt) (BgL_thz00_3717);
								BgL_arg1934z00_4599 = BGL_CLASS_DEPTH(BgL_classz00_4596);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 435 */
										long BgL_idxz00_4607;

										BgL_idxz00_4607 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4598);
										{	/* Llib/thread.scm 435 */
											obj_t BgL_arg1925z00_4608;

											{	/* Llib/thread.scm 435 */
												long BgL_arg1926z00_4609;

												BgL_arg1926z00_4609 =
													(BgL_idxz00_4607 + BgL_arg1934z00_4599);
												BgL_arg1925z00_4608 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4609);
											}
											BgL_test2738z00_6568 =
												(BgL_arg1925z00_4608 == BgL_classz00_4596);
									}}
								else
									{	/* Llib/thread.scm 435 */
										bool_t BgL_res2043z00_4614;

										{	/* Llib/thread.scm 435 */
											obj_t BgL_oclassz00_4618;

											{	/* Llib/thread.scm 435 */
												long BgL_arg1938z00_4620;

												{	/* Llib/thread.scm 435 */
													long BgL_arg1939z00_4621;

													BgL_arg1939z00_4621 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4598);
													BgL_arg1938z00_4620 =
														(BgL_arg1939z00_4621 - OBJECT_TYPE);
												}
												BgL_oclassz00_4618 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4620);
											}
											{	/* Llib/thread.scm 435 */
												bool_t BgL__ortest_1147z00_4627;

												BgL__ortest_1147z00_4627 =
													(BgL_classz00_4596 == BgL_oclassz00_4618);
												if (BgL__ortest_1147z00_4627)
													{	/* Llib/thread.scm 435 */
														BgL_res2043z00_4614 = BgL__ortest_1147z00_4627;
													}
												else
													{	/* Llib/thread.scm 435 */
														long BgL_odepthz00_4628;

														BgL_odepthz00_4628 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4618);
														if ((BgL_arg1934z00_4599 < BgL_odepthz00_4628))
															{	/* Llib/thread.scm 435 */
																obj_t BgL_arg1927z00_4632;

																BgL_arg1927z00_4632 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4618,
																	BgL_arg1934z00_4599);
																BgL_res2043z00_4614 =
																	(BgL_arg1927z00_4632 == BgL_classz00_4596);
															}
														else
															{	/* Llib/thread.scm 435 */
																BgL_res2043z00_4614 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2738z00_6568 = BgL_res2043z00_4614;
									}
							}
						else
							{	/* Llib/thread.scm 435 */
								BgL_test2738z00_6568 = ((bool_t) 0);
							}
					}
					if (BgL_test2738z00_6568)
						{	/* Llib/thread.scm 435 */
							BgL_auxz00_6567 = ((BgL_threadz00_bglt) BgL_thz00_3717);
						}
					else
						{
							obj_t BgL_auxz00_6590;

							BgL_auxz00_6590 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(18612L), BGl_string2336z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3717);
							FAILURE(BgL_auxz00_6590, BFALSE, BFALSE);
						}
				}
				return BGl_threadzd2namezd2zz__threadz00(BgL_auxz00_6567);
			}
		}

	}



/* 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_method1220z00_1660;

				{	/* Llib/thread.scm 440 */
					obj_t BgL_res2025z00_2970;

					{	/* Llib/thread.scm 440 */
						long BgL_objzd2classzd2numz00_2941;

						BgL_objzd2classzd2numz00_2941 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_thz00_42));
						{	/* Llib/thread.scm 440 */
							obj_t BgL_arg1935z00_2942;

							BgL_arg1935z00_2942 =
								PROCEDURE_REF(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 440 */
								int BgL_offsetz00_2945;

								BgL_offsetz00_2945 = (int) (BgL_objzd2classzd2numz00_2941);
								{	/* Llib/thread.scm 440 */
									long BgL_offsetz00_2946;

									BgL_offsetz00_2946 =
										((long) (BgL_offsetz00_2945) - OBJECT_TYPE);
									{	/* Llib/thread.scm 440 */
										long BgL_modz00_2947;

										BgL_modz00_2947 =
											(BgL_offsetz00_2946 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 440 */
											long BgL_restz00_2949;

											BgL_restz00_2949 =
												(BgL_offsetz00_2946 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 440 */

												{	/* Llib/thread.scm 440 */
													obj_t BgL_bucketz00_2951;

													BgL_bucketz00_2951 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2942), BgL_modz00_2947);
													BgL_res2025z00_2970 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2951), BgL_restz00_2949);
					}}}}}}}}
					BgL_method1220z00_1660 = BgL_res2025z00_2970;
				}
				return
					(VA_PROCEDUREP(BgL_method1220z00_1660) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1220z00_1660)) (BgL_method1220z00_1660,
						((obj_t) BgL_thz00_42), BgL_vz00_43, BEOA) : ((obj_t(*)(obj_t,
								obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1220z00_1660)) (BgL_method1220z00_1660,
						((obj_t) BgL_thz00_42), BgL_vz00_43));
			}
		}

	}



/* &thread-name-set! */
	obj_t BGl_z62threadzd2namezd2setz12z70zz__threadz00(obj_t BgL_envz00_3718,
		obj_t BgL_thz00_3719, obj_t BgL_vz00_3720)
	{
		{	/* Llib/thread.scm 440 */
			{	/* Llib/thread.scm 440 */
				obj_t BgL_auxz00_6653;
				BgL_threadz00_bglt BgL_auxz00_6626;

				if (STRINGP(BgL_vz00_3720))
					{	/* Llib/thread.scm 440 */
						BgL_auxz00_6653 = BgL_vz00_3720;
					}
				else
					{
						obj_t BgL_auxz00_6656;

						BgL_auxz00_6656 =
							BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
							BINT(18877L), BGl_string2337z00zz__threadz00,
							BGl_string2168z00zz__threadz00, BgL_vz00_3720);
						FAILURE(BgL_auxz00_6656, BFALSE, BFALSE);
					}
				{	/* Llib/thread.scm 440 */
					bool_t BgL_test2743z00_6627;

					{	/* Llib/thread.scm 440 */
						obj_t BgL_classz00_4633;

						BgL_classz00_4633 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_thz00_3719))
							{	/* Llib/thread.scm 440 */
								BgL_objectz00_bglt BgL_arg1933z00_4635;
								long BgL_arg1934z00_4636;

								BgL_arg1933z00_4635 = (BgL_objectz00_bglt) (BgL_thz00_3719);
								BgL_arg1934z00_4636 = BGL_CLASS_DEPTH(BgL_classz00_4633);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 440 */
										long BgL_idxz00_4644;

										BgL_idxz00_4644 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4635);
										{	/* Llib/thread.scm 440 */
											obj_t BgL_arg1925z00_4645;

											{	/* Llib/thread.scm 440 */
												long BgL_arg1926z00_4646;

												BgL_arg1926z00_4646 =
													(BgL_idxz00_4644 + BgL_arg1934z00_4636);
												BgL_arg1925z00_4645 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4646);
											}
											BgL_test2743z00_6627 =
												(BgL_arg1925z00_4645 == BgL_classz00_4633);
									}}
								else
									{	/* Llib/thread.scm 440 */
										bool_t BgL_res2043z00_4651;

										{	/* Llib/thread.scm 440 */
											obj_t BgL_oclassz00_4655;

											{	/* Llib/thread.scm 440 */
												long BgL_arg1938z00_4657;

												{	/* Llib/thread.scm 440 */
													long BgL_arg1939z00_4658;

													BgL_arg1939z00_4658 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4635);
													BgL_arg1938z00_4657 =
														(BgL_arg1939z00_4658 - OBJECT_TYPE);
												}
												BgL_oclassz00_4655 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4657);
											}
											{	/* Llib/thread.scm 440 */
												bool_t BgL__ortest_1147z00_4664;

												BgL__ortest_1147z00_4664 =
													(BgL_classz00_4633 == BgL_oclassz00_4655);
												if (BgL__ortest_1147z00_4664)
													{	/* Llib/thread.scm 440 */
														BgL_res2043z00_4651 = BgL__ortest_1147z00_4664;
													}
												else
													{	/* Llib/thread.scm 440 */
														long BgL_odepthz00_4665;

														BgL_odepthz00_4665 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4655);
														if ((BgL_arg1934z00_4636 < BgL_odepthz00_4665))
															{	/* Llib/thread.scm 440 */
																obj_t BgL_arg1927z00_4669;

																BgL_arg1927z00_4669 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4655,
																	BgL_arg1934z00_4636);
																BgL_res2043z00_4651 =
																	(BgL_arg1927z00_4669 == BgL_classz00_4633);
															}
														else
															{	/* Llib/thread.scm 440 */
																BgL_res2043z00_4651 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2743z00_6627 = BgL_res2043z00_4651;
									}
							}
						else
							{	/* Llib/thread.scm 440 */
								BgL_test2743z00_6627 = ((bool_t) 0);
							}
					}
					if (BgL_test2743z00_6627)
						{	/* Llib/thread.scm 440 */
							BgL_auxz00_6626 = ((BgL_threadz00_bglt) BgL_thz00_3719);
						}
					else
						{
							obj_t BgL_auxz00_6649;

							BgL_auxz00_6649 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(18877L), BGl_string2337z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_thz00_3719);
							FAILURE(BgL_auxz00_6649, BFALSE, BFALSE);
						}
				}
				return
					BGl_threadzd2namezd2setz12z12zz__threadz00(BgL_auxz00_6626,
					BgL_auxz00_6653);
			}
		}

	}



/* %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_1661;

				{	/* Llib/thread.scm 451 */
					obj_t BgL_res2030z00_3001;

					{	/* Llib/thread.scm 451 */
						long BgL_objzd2classzd2numz00_2972;

						BgL_objzd2classzd2numz00_2972 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_48));
						{	/* Llib/thread.scm 451 */
							obj_t BgL_arg1935z00_2973;

							BgL_arg1935z00_2973 =
								PROCEDURE_REF
								(BGl_z52userzd2currentzd2threadzd2envz80zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 451 */
								int BgL_offsetz00_2976;

								BgL_offsetz00_2976 = (int) (BgL_objzd2classzd2numz00_2972);
								{	/* Llib/thread.scm 451 */
									long BgL_offsetz00_2977;

									BgL_offsetz00_2977 =
										((long) (BgL_offsetz00_2976) - OBJECT_TYPE);
									{	/* Llib/thread.scm 451 */
										long BgL_modz00_2978;

										BgL_modz00_2978 =
											(BgL_offsetz00_2977 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 451 */
											long BgL_restz00_2980;

											BgL_restz00_2980 =
												(BgL_offsetz00_2977 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 451 */

												{	/* Llib/thread.scm 451 */
													obj_t BgL_bucketz00_2982;

													BgL_bucketz00_2982 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_2973), BgL_modz00_2978);
													BgL_res2030z00_3001 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_2982), BgL_restz00_2980);
					}}}}}}}}
					BgL_method1227z00_1661 = BgL_res2030z00_3001;
				}
				return
					(VA_PROCEDUREP(BgL_method1227z00_1661) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1227z00_1661)) (BgL_method1227z00_1661,
						((obj_t) BgL_oz00_48), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1227z00_1661)) (BgL_method1227z00_1661,
						((obj_t) BgL_oz00_48)));
			}
		}

	}



/* &%user-current-thread */
	obj_t BGl_z62z52userzd2currentzd2threadz30zz__threadz00(obj_t BgL_envz00_3721,
		obj_t BgL_oz00_3722)
	{
		{	/* Llib/thread.scm 451 */
			{	/* Llib/thread.scm 451 */
				BgL_threadz00_bglt BgL_auxz00_6691;

				{	/* Llib/thread.scm 451 */
					bool_t BgL_test2749z00_6692;

					{	/* Llib/thread.scm 451 */
						obj_t BgL_classz00_4670;

						BgL_classz00_4670 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3722))
							{	/* Llib/thread.scm 451 */
								BgL_objectz00_bglt BgL_arg1933z00_4672;
								long BgL_arg1934z00_4673;

								BgL_arg1933z00_4672 = (BgL_objectz00_bglt) (BgL_oz00_3722);
								BgL_arg1934z00_4673 = BGL_CLASS_DEPTH(BgL_classz00_4670);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 451 */
										long BgL_idxz00_4681;

										BgL_idxz00_4681 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4672);
										{	/* Llib/thread.scm 451 */
											obj_t BgL_arg1925z00_4682;

											{	/* Llib/thread.scm 451 */
												long BgL_arg1926z00_4683;

												BgL_arg1926z00_4683 =
													(BgL_idxz00_4681 + BgL_arg1934z00_4673);
												BgL_arg1925z00_4682 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4683);
											}
											BgL_test2749z00_6692 =
												(BgL_arg1925z00_4682 == BgL_classz00_4670);
									}}
								else
									{	/* Llib/thread.scm 451 */
										bool_t BgL_res2043z00_4688;

										{	/* Llib/thread.scm 451 */
											obj_t BgL_oclassz00_4692;

											{	/* Llib/thread.scm 451 */
												long BgL_arg1938z00_4694;

												{	/* Llib/thread.scm 451 */
													long BgL_arg1939z00_4695;

													BgL_arg1939z00_4695 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4672);
													BgL_arg1938z00_4694 =
														(BgL_arg1939z00_4695 - OBJECT_TYPE);
												}
												BgL_oclassz00_4692 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4694);
											}
											{	/* Llib/thread.scm 451 */
												bool_t BgL__ortest_1147z00_4701;

												BgL__ortest_1147z00_4701 =
													(BgL_classz00_4670 == BgL_oclassz00_4692);
												if (BgL__ortest_1147z00_4701)
													{	/* Llib/thread.scm 451 */
														BgL_res2043z00_4688 = BgL__ortest_1147z00_4701;
													}
												else
													{	/* Llib/thread.scm 451 */
														long BgL_odepthz00_4702;

														BgL_odepthz00_4702 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4692);
														if ((BgL_arg1934z00_4673 < BgL_odepthz00_4702))
															{	/* Llib/thread.scm 451 */
																obj_t BgL_arg1927z00_4706;

																BgL_arg1927z00_4706 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4692,
																	BgL_arg1934z00_4673);
																BgL_res2043z00_4688 =
																	(BgL_arg1927z00_4706 == BgL_classz00_4670);
															}
														else
															{	/* Llib/thread.scm 451 */
																BgL_res2043z00_4688 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2749z00_6692 = BgL_res2043z00_4688;
									}
							}
						else
							{	/* Llib/thread.scm 451 */
								BgL_test2749z00_6692 = ((bool_t) 0);
							}
					}
					if (BgL_test2749z00_6692)
						{	/* Llib/thread.scm 451 */
							BgL_auxz00_6691 = ((BgL_threadz00_bglt) BgL_oz00_3722);
						}
					else
						{
							obj_t BgL_auxz00_6714;

							BgL_auxz00_6714 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(19506L), BGl_string2338z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_oz00_3722);
							FAILURE(BgL_auxz00_6714, BFALSE, BFALSE);
						}
				}
				return BGl_z52userzd2currentzd2threadz52zz__threadz00(BgL_auxz00_6691);
			}
		}

	}



/* %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_method1229z00_1662;

				{	/* Llib/thread.scm 473 */
					obj_t BgL_res2035z00_3032;

					{	/* Llib/thread.scm 473 */
						long BgL_objzd2classzd2numz00_3003;

						BgL_objzd2classzd2numz00_3003 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_49));
						{	/* Llib/thread.scm 473 */
							obj_t BgL_arg1935z00_3004;

							BgL_arg1935z00_3004 =
								PROCEDURE_REF
								(BGl_z52userzd2threadzd2sleepz12zd2envz92zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 473 */
								int BgL_offsetz00_3007;

								BgL_offsetz00_3007 = (int) (BgL_objzd2classzd2numz00_3003);
								{	/* Llib/thread.scm 473 */
									long BgL_offsetz00_3008;

									BgL_offsetz00_3008 =
										((long) (BgL_offsetz00_3007) - OBJECT_TYPE);
									{	/* Llib/thread.scm 473 */
										long BgL_modz00_3009;

										BgL_modz00_3009 =
											(BgL_offsetz00_3008 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 473 */
											long BgL_restz00_3011;

											BgL_restz00_3011 =
												(BgL_offsetz00_3008 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 473 */

												{	/* Llib/thread.scm 473 */
													obj_t BgL_bucketz00_3013;

													BgL_bucketz00_3013 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_3004), BgL_modz00_3009);
													BgL_res2035z00_3032 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_3013), BgL_restz00_3011);
					}}}}}}}}
					BgL_method1229z00_1662 = BgL_res2035z00_3032;
				}
				return
					(VA_PROCEDUREP(BgL_method1229z00_1662) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1229z00_1662)) (BgL_method1229z00_1662,
						((obj_t) BgL_oz00_49), BgL_dz00_50, BEOA) : ((obj_t(*)(obj_t, obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1229z00_1662)) (BgL_method1229z00_1662,
						((obj_t) BgL_oz00_49), BgL_dz00_50));
			}
		}

	}



/* &%user-thread-sleep! */
	obj_t BGl_z62z52userzd2threadzd2sleepz12z22zz__threadz00(obj_t
		BgL_envz00_3723, obj_t BgL_oz00_3724, obj_t BgL_dz00_3725)
	{
		{	/* Llib/thread.scm 473 */
			{	/* Llib/thread.scm 473 */
				BgL_threadz00_bglt BgL_auxz00_6750;

				{	/* Llib/thread.scm 473 */
					bool_t BgL_test2754z00_6751;

					{	/* Llib/thread.scm 473 */
						obj_t BgL_classz00_4707;

						BgL_classz00_4707 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3724))
							{	/* Llib/thread.scm 473 */
								BgL_objectz00_bglt BgL_arg1933z00_4709;
								long BgL_arg1934z00_4710;

								BgL_arg1933z00_4709 = (BgL_objectz00_bglt) (BgL_oz00_3724);
								BgL_arg1934z00_4710 = BGL_CLASS_DEPTH(BgL_classz00_4707);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 473 */
										long BgL_idxz00_4718;

										BgL_idxz00_4718 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4709);
										{	/* Llib/thread.scm 473 */
											obj_t BgL_arg1925z00_4719;

											{	/* Llib/thread.scm 473 */
												long BgL_arg1926z00_4720;

												BgL_arg1926z00_4720 =
													(BgL_idxz00_4718 + BgL_arg1934z00_4710);
												BgL_arg1925z00_4719 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4720);
											}
											BgL_test2754z00_6751 =
												(BgL_arg1925z00_4719 == BgL_classz00_4707);
									}}
								else
									{	/* Llib/thread.scm 473 */
										bool_t BgL_res2043z00_4725;

										{	/* Llib/thread.scm 473 */
											obj_t BgL_oclassz00_4729;

											{	/* Llib/thread.scm 473 */
												long BgL_arg1938z00_4731;

												{	/* Llib/thread.scm 473 */
													long BgL_arg1939z00_4732;

													BgL_arg1939z00_4732 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4709);
													BgL_arg1938z00_4731 =
														(BgL_arg1939z00_4732 - OBJECT_TYPE);
												}
												BgL_oclassz00_4729 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4731);
											}
											{	/* Llib/thread.scm 473 */
												bool_t BgL__ortest_1147z00_4738;

												BgL__ortest_1147z00_4738 =
													(BgL_classz00_4707 == BgL_oclassz00_4729);
												if (BgL__ortest_1147z00_4738)
													{	/* Llib/thread.scm 473 */
														BgL_res2043z00_4725 = BgL__ortest_1147z00_4738;
													}
												else
													{	/* Llib/thread.scm 473 */
														long BgL_odepthz00_4739;

														BgL_odepthz00_4739 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4729);
														if ((BgL_arg1934z00_4710 < BgL_odepthz00_4739))
															{	/* Llib/thread.scm 473 */
																obj_t BgL_arg1927z00_4743;

																BgL_arg1927z00_4743 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4729,
																	BgL_arg1934z00_4710);
																BgL_res2043z00_4725 =
																	(BgL_arg1927z00_4743 == BgL_classz00_4707);
															}
														else
															{	/* Llib/thread.scm 473 */
																BgL_res2043z00_4725 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2754z00_6751 = BgL_res2043z00_4725;
									}
							}
						else
							{	/* Llib/thread.scm 473 */
								BgL_test2754z00_6751 = ((bool_t) 0);
							}
					}
					if (BgL_test2754z00_6751)
						{	/* Llib/thread.scm 473 */
							BgL_auxz00_6750 = ((BgL_threadz00_bglt) BgL_oz00_3724);
						}
					else
						{
							obj_t BgL_auxz00_6773;

							BgL_auxz00_6773 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(20480L), BGl_string2339z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_oz00_3724);
							FAILURE(BgL_auxz00_6773, BFALSE, BFALSE);
						}
				}
				return
					BGl_z52userzd2threadzd2sleepz12z40zz__threadz00(BgL_auxz00_6750,
					BgL_dz00_3725);
			}
		}

	}



/* %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_method1231z00_1663;

				{	/* Llib/thread.scm 500 */
					obj_t BgL_res2040z00_3063;

					{	/* Llib/thread.scm 500 */
						long BgL_objzd2classzd2numz00_3034;

						BgL_objzd2classzd2numz00_3034 =
							BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_52));
						{	/* Llib/thread.scm 500 */
							obj_t BgL_arg1935z00_3035;

							BgL_arg1935z00_3035 =
								PROCEDURE_REF
								(BGl_z52userzd2threadzd2yieldz12zd2envz92zz__threadz00,
								(int) (1L));
							{	/* Llib/thread.scm 500 */
								int BgL_offsetz00_3038;

								BgL_offsetz00_3038 = (int) (BgL_objzd2classzd2numz00_3034);
								{	/* Llib/thread.scm 500 */
									long BgL_offsetz00_3039;

									BgL_offsetz00_3039 =
										((long) (BgL_offsetz00_3038) - OBJECT_TYPE);
									{	/* Llib/thread.scm 500 */
										long BgL_modz00_3040;

										BgL_modz00_3040 =
											(BgL_offsetz00_3039 >> (int) ((long) ((int) (4L))));
										{	/* Llib/thread.scm 500 */
											long BgL_restz00_3042;

											BgL_restz00_3042 =
												(BgL_offsetz00_3039 &
												(long) (
													(int) (
														((long) (
																(int) (
																	(1L <<
																		(int) ((long) ((int) (4L)))))) - 1L))));
											{	/* Llib/thread.scm 500 */

												{	/* Llib/thread.scm 500 */
													obj_t BgL_bucketz00_3044;

													BgL_bucketz00_3044 =
														VECTOR_REF(
														((obj_t) BgL_arg1935z00_3035), BgL_modz00_3040);
													BgL_res2040z00_3063 =
														VECTOR_REF(
														((obj_t) BgL_bucketz00_3044), BgL_restz00_3042);
					}}}}}}}}
					BgL_method1231z00_1663 = BgL_res2040z00_3063;
				}
				return
					(VA_PROCEDUREP(BgL_method1231z00_1663) ? ((obj_t(*)(obj_t,
								...))
						PROCEDURE_ENTRY(BgL_method1231z00_1663)) (BgL_method1231z00_1663,
						((obj_t) BgL_oz00_52), BEOA) : ((obj_t(*)(obj_t,
								obj_t))
						PROCEDURE_ENTRY(BgL_method1231z00_1663)) (BgL_method1231z00_1663,
						((obj_t) BgL_oz00_52)));
			}
		}

	}



/* &%user-thread-yield! */
	obj_t BGl_z62z52userzd2threadzd2yieldz12z22zz__threadz00(obj_t
		BgL_envz00_3726, obj_t BgL_oz00_3727)
	{
		{	/* Llib/thread.scm 500 */
			{	/* Llib/thread.scm 500 */
				BgL_threadz00_bglt BgL_auxz00_6808;

				{	/* Llib/thread.scm 500 */
					bool_t BgL_test2759z00_6809;

					{	/* Llib/thread.scm 500 */
						obj_t BgL_classz00_4744;

						BgL_classz00_4744 = BGl_threadz00zz__threadz00;
						if (BGL_OBJECTP(BgL_oz00_3727))
							{	/* Llib/thread.scm 500 */
								BgL_objectz00_bglt BgL_arg1933z00_4746;
								long BgL_arg1934z00_4747;

								BgL_arg1933z00_4746 = (BgL_objectz00_bglt) (BgL_oz00_3727);
								BgL_arg1934z00_4747 = BGL_CLASS_DEPTH(BgL_classz00_4744);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 500 */
										long BgL_idxz00_4755;

										BgL_idxz00_4755 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1933z00_4746);
										{	/* Llib/thread.scm 500 */
											obj_t BgL_arg1925z00_4756;

											{	/* Llib/thread.scm 500 */
												long BgL_arg1926z00_4757;

												BgL_arg1926z00_4757 =
													(BgL_idxz00_4755 + BgL_arg1934z00_4747);
												BgL_arg1925z00_4756 =
													VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
													BgL_arg1926z00_4757);
											}
											BgL_test2759z00_6809 =
												(BgL_arg1925z00_4756 == BgL_classz00_4744);
									}}
								else
									{	/* Llib/thread.scm 500 */
										bool_t BgL_res2043z00_4762;

										{	/* Llib/thread.scm 500 */
											obj_t BgL_oclassz00_4766;

											{	/* Llib/thread.scm 500 */
												long BgL_arg1938z00_4768;

												{	/* Llib/thread.scm 500 */
													long BgL_arg1939z00_4769;

													BgL_arg1939z00_4769 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1933z00_4746);
													BgL_arg1938z00_4768 =
														(BgL_arg1939z00_4769 - OBJECT_TYPE);
												}
												BgL_oclassz00_4766 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4768);
											}
											{	/* Llib/thread.scm 500 */
												bool_t BgL__ortest_1147z00_4775;

												BgL__ortest_1147z00_4775 =
													(BgL_classz00_4744 == BgL_oclassz00_4766);
												if (BgL__ortest_1147z00_4775)
													{	/* Llib/thread.scm 500 */
														BgL_res2043z00_4762 = BgL__ortest_1147z00_4775;
													}
												else
													{	/* Llib/thread.scm 500 */
														long BgL_odepthz00_4776;

														BgL_odepthz00_4776 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4766);
														if ((BgL_arg1934z00_4747 < BgL_odepthz00_4776))
															{	/* Llib/thread.scm 500 */
																obj_t BgL_arg1927z00_4780;

																BgL_arg1927z00_4780 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4766,
																	BgL_arg1934z00_4747);
																BgL_res2043z00_4762 =
																	(BgL_arg1927z00_4780 == BgL_classz00_4744);
															}
														else
															{	/* Llib/thread.scm 500 */
																BgL_res2043z00_4762 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2759z00_6809 = BgL_res2043z00_4762;
									}
							}
						else
							{	/* Llib/thread.scm 500 */
								BgL_test2759z00_6809 = ((bool_t) 0);
							}
					}
					if (BgL_test2759z00_6809)
						{	/* Llib/thread.scm 500 */
							BgL_auxz00_6808 = ((BgL_threadz00_bglt) BgL_oz00_3727);
						}
					else
						{
							obj_t BgL_auxz00_6831;

							BgL_auxz00_6831 =
								BGl_typezd2errorzd2zz__errorz00(BGl_string2163z00zz__threadz00,
								BINT(21576L), BGl_string2340z00zz__threadz00,
								BGl_string2170z00zz__threadz00, BgL_oz00_3727);
							FAILURE(BgL_auxz00_6831, BFALSE, BFALSE);
						}
				}
				return BGl_z52userzd2threadzd2yieldz12z40zz__threadz00(BgL_auxz00_6808);
			}
		}

	}



/* method-init */
	obj_t BGl_methodzd2initzd2zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_tbzd2makezd2threadzd2envzd2zz__threadz00,
				BGl_nothreadzd2backendzd2zz__threadz00, BGl_proc2341z00zz__threadz00,
				BGl_string2342z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_tbzd2currentzd2threadzd2envzd2zz__threadz00,
				BGl_nothreadzd2backendzd2zz__threadz00, BGl_proc2343z00zz__threadz00,
				BGl_string2344z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2displayzd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2345z00zz__threadz00, BGl_string2346z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2writezd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2347z00zz__threadz00, BGl_string2348z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_objectzd2printzd2envz00zz__objectz00, BGl_threadz00zz__threadz00,
				BGl_proc2349z00zz__threadz00, BGl_string2350z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2startz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2351z00zz__threadz00,
				BGl_string2352z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2startzd2joinablez12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2353z00zz__threadz00,
				BGl_string2354z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2joinz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2355z00zz__threadz00,
				BGl_string2356z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2terminatez12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2357z00zz__threadz00,
				BGl_string2358z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2killz12zd2envz12zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2359z00zz__threadz00,
				BGl_string2360z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2specificzd2envz00zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2361z00zz__threadz00,
				BGl_string2362z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2specificzd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2363z00zz__threadz00,
				BGl_string2364z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2cleanupzd2envz00zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2365z00zz__threadz00,
				BGl_string2366z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2cleanupzd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2367z00zz__threadz00,
				BGl_string2368z00zz__threadz00);
			BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2namezd2envz00zz__threadz00, BGl_nothreadz00zz__threadz00,
				BGl_proc2369z00zz__threadz00, BGl_string2370z00zz__threadz00);
			return
				BGl_genericzd2addzd2methodz12z12zz__objectz00
				(BGl_threadzd2namezd2setz12zd2envzc0zz__threadz00,
				BGl_nothreadz00zz__threadz00, BGl_proc2371z00zz__threadz00,
				BGl_string2372z00zz__threadz00);
		}

	}



/* &thread-name-set!-not1253 */
	obj_t BGl_z62threadzd2namezd2setz12zd2not1253za2zz__threadz00(obj_t
		BgL_envz00_3747, obj_t BgL_thz00_3748, obj_t BgL_vz00_3749)
	{
		{	/* Llib/thread.scm 608 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3748)))->BgL_z52namez52) =
				((obj_t) BgL_vz00_3749), BUNSPEC);
		}

	}



/* &thread-name-nothread1251 */
	obj_t BGl_z62threadzd2namezd2nothread1251z62zz__threadz00(obj_t
		BgL_envz00_3750, obj_t BgL_thz00_3751)
	{
		{	/* Llib/thread.scm 602 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3751)))->BgL_z52namez52);
		}

	}



/* &thread-cleanup-set!-1249 */
	obj_t BGl_z62threadzd2cleanupzd2setz12zd21249za2zz__threadz00(obj_t
		BgL_envz00_3752, obj_t BgL_thz00_3753, obj_t BgL_vz00_3754)
	{
		{	/* Llib/thread.scm 596 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3753)))->BgL_z52cleanupz52) =
				((obj_t) BgL_vz00_3754), BUNSPEC);
		}

	}



/* &thread-cleanup-nothr1247 */
	obj_t BGl_z62threadzd2cleanupzd2nothr1247z62zz__threadz00(obj_t
		BgL_envz00_3755, obj_t BgL_thz00_3756)
	{
		{	/* Llib/thread.scm 590 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3756)))->BgL_z52cleanupz52);
		}

	}



/* &thread-specific-set!1245 */
	obj_t BGl_z62threadzd2specificzd2setz121245z70zz__threadz00(obj_t
		BgL_envz00_3757, obj_t BgL_thz00_3758, obj_t BgL_vz00_3759)
	{
		{	/* Llib/thread.scm 584 */
			return
				((((BgL_nothreadz00_bglt) COBJECT(
							((BgL_nothreadz00_bglt) BgL_thz00_3758)))->BgL_z52specificz52) =
				((obj_t) BgL_vz00_3759), BUNSPEC);
		}

	}



/* &thread-specific-noth1243 */
	obj_t BGl_z62threadzd2specificzd2noth1243z62zz__threadz00(obj_t
		BgL_envz00_3760, obj_t BgL_thz00_3761)
	{
		{	/* Llib/thread.scm 578 */
			return
				(((BgL_nothreadz00_bglt) COBJECT(
						((BgL_nothreadz00_bglt) BgL_thz00_3761)))->BgL_z52specificz52);
		}

	}



/* &thread-kill!-nothrea1241 */
	obj_t BGl_z62threadzd2killz12zd2nothrea1241z70zz__threadz00(obj_t
		BgL_envz00_3762, obj_t BgL_thz00_3763, obj_t BgL_nz00_3764)
	{
		{	/* Llib/thread.scm 572 */
			return BUNSPEC;
		}

	}



/* &thread-terminate!-no1239 */
	obj_t BGl_z62threadzd2terminatez12zd2no1239z70zz__threadz00(obj_t
		BgL_envz00_3765, obj_t BgL_thz00_3766)
	{
		{	/* Llib/thread.scm 564 */
			{	/* Llib/thread.scm 566 */
				bool_t BgL_test2764z00_6864;

				{	/* Llib/thread.scm 566 */
					obj_t BgL_tmpz00_6865;

					BgL_tmpz00_6865 =
						(((BgL_nothreadz00_bglt) COBJECT(
								((BgL_nothreadz00_bglt) BgL_thz00_3766)))->BgL_z52cleanupz52);
					BgL_test2764z00_6864 = PROCEDUREP(BgL_tmpz00_6865);
				}
				if (BgL_test2764z00_6864)
					{	/* Llib/thread.scm 566 */
						obj_t BgL_fun1580z00_4790;

						BgL_fun1580z00_4790 =
							(((BgL_nothreadz00_bglt) COBJECT(
									((BgL_nothreadz00_bglt) BgL_thz00_3766)))->BgL_z52cleanupz52);
						(VA_PROCEDUREP(BgL_fun1580z00_4790) ? ((obj_t(*)(obj_t,
										...))
								PROCEDURE_ENTRY(BgL_fun1580z00_4790)) (BgL_fun1580z00_4790,
								BEOA) : ((obj_t(*)(obj_t))
								PROCEDURE_ENTRY(BgL_fun1580z00_4790)) (BgL_fun1580z00_4790));
					}
				else
					{	/* Llib/thread.scm 566 */
						BFALSE;
					}
			}
			{	/* Llib/thread.scm 567 */
				obj_t BgL_list1582z00_4791;

				BgL_list1582z00_4791 = MAKE_YOUNG_PAIR(BINT(0L), BNIL);
				return BGl_exitz00zz__errorz00(BgL_list1582z00_4791);
			}
		}

	}



/* &thread-join!-nothrea1237 */
	obj_t BGl_z62threadzd2joinz12zd2nothrea1237z70zz__threadz00(obj_t
		BgL_envz00_3767, obj_t BgL_thz00_3768, obj_t BgL_timeoutz00_3769)
	{
		{	/* Llib/thread.scm 555 */
			{	/* Llib/thread.scm 557 */
				bool_t BgL_test2765z00_6877;

				{	/* Llib/thread.scm 557 */
					obj_t BgL_arg1576z00_4793;

					BgL_arg1576z00_4793 =
						(((BgL_nothreadz00_bglt) COBJECT(
								((BgL_nothreadz00_bglt) BgL_thz00_3768)))->
						BgL_endzd2exceptionzd2);
					{	/* Llib/thread.scm 557 */
						obj_t BgL_classz00_4794;

						BgL_classz00_4794 = BGl_z62exceptionz62zz__objectz00;
						if (BGL_OBJECTP(BgL_arg1576z00_4793))
							{	/* Llib/thread.scm 557 */
								BgL_objectz00_bglt BgL_arg1930z00_4795;

								BgL_arg1930z00_4795 =
									(BgL_objectz00_bglt) (BgL_arg1576z00_4793);
								if (BGL_CONDEXPAND_ISA_ARCH64())
									{	/* Llib/thread.scm 557 */
										long BgL_idxz00_4796;

										BgL_idxz00_4796 =
											BGL_OBJECT_INHERITANCE_NUM(BgL_arg1930z00_4795);
										BgL_test2765z00_6877 =
											(VECTOR_REF(BGl_za2inheritancesza2z00zz__objectz00,
												(BgL_idxz00_4796 + 2L)) == BgL_classz00_4794);
									}
								else
									{	/* Llib/thread.scm 557 */
										bool_t BgL_res2041z00_4799;

										{	/* Llib/thread.scm 557 */
											obj_t BgL_oclassz00_4800;

											{	/* Llib/thread.scm 557 */
												long BgL_arg1938z00_4801;

												{	/* Llib/thread.scm 557 */
													long BgL_arg1939z00_4802;

													BgL_arg1939z00_4802 =
														BGL_OBJECT_CLASS_NUM(BgL_arg1930z00_4795);
													BgL_arg1938z00_4801 =
														(BgL_arg1939z00_4802 - OBJECT_TYPE);
												}
												BgL_oclassz00_4800 =
													VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
													BgL_arg1938z00_4801);
											}
											{	/* Llib/thread.scm 557 */
												bool_t BgL__ortest_1147z00_4803;

												BgL__ortest_1147z00_4803 =
													(BgL_classz00_4794 == BgL_oclassz00_4800);
												if (BgL__ortest_1147z00_4803)
													{	/* Llib/thread.scm 557 */
														BgL_res2041z00_4799 = BgL__ortest_1147z00_4803;
													}
												else
													{	/* Llib/thread.scm 557 */
														long BgL_odepthz00_4804;

														BgL_odepthz00_4804 =
															BGL_CLASS_DEPTH(BgL_oclassz00_4800);
														if ((2L < BgL_odepthz00_4804))
															{	/* Llib/thread.scm 557 */
																obj_t BgL_arg1927z00_4805;

																BgL_arg1927z00_4805 =
																	BGL_CLASS_ANCESTORS_REF(BgL_oclassz00_4800,
																	2L);
																BgL_res2041z00_4799 =
																	(BgL_arg1927z00_4805 == BgL_classz00_4794);
															}
														else
															{	/* Llib/thread.scm 557 */
																BgL_res2041z00_4799 = ((bool_t) 0);
															}
													}
											}
										}
										BgL_test2765z00_6877 = BgL_res2041z00_4799;
									}
							}
						else
							{	/* Llib/thread.scm 557 */
								BgL_test2765z00_6877 = ((bool_t) 0);
							}
					}
				}
				if (BgL_test2765z00_6877)
					{	/* Llib/thread.scm 557 */
						return
							BGl_raisez00zz__errorz00(
							(((BgL_nothreadz00_bglt) COBJECT(
										((BgL_nothreadz00_bglt) BgL_thz00_3768)))->
								BgL_endzd2exceptionzd2));
					}
				else
					{	/* Llib/thread.scm 557 */
						return
							(((BgL_nothreadz00_bglt) COBJECT(
									((BgL_nothreadz00_bglt) BgL_thz00_3768)))->
							BgL_endzd2resultzd2);
					}
			}
		}

	}



/* &thread-start-joinabl1235 */
	obj_t BGl_z62threadzd2startzd2joinabl1235z62zz__threadz00(obj_t
		BgL_envz00_3770, obj_t BgL_thz00_3771)
	{
		{	/* Llib/thread.scm 549 */
			return
				BGl_threadzd2startz12zc0zz__threadz00(
				((BgL_threadz00_bglt) ((BgL_nothreadz00_bglt) BgL_thz00_3771)), BNIL);
		}

	}



/* &thread-start!-nothre1233 */
	obj_t BGl_z62threadzd2startz12zd2nothre1233z70zz__threadz00(obj_t
		BgL_envz00_3772, obj_t BgL_thz00_3773, obj_t BgL_scdz00_3774)
	{
		{	/* Llib/thread.scm 533 */
			{	/* Llib/thread.scm 534 */
				obj_t BgL_threadz00_4808;

				BgL_threadz00_4808 = BGl_za2nothreadzd2currentza2zd2zz__threadz00;
				{	/* Llib/thread.scm 535 */
					obj_t BgL_exitd1067z00_4809;

					BgL_exitd1067z00_4809 = BGL_EXITD_TOP_AS_OBJ();
					{	/* Llib/thread.scm 544 */
						obj_t BgL_zc3z04anonymousza31565ze3z87_4810;

						BgL_zc3z04anonymousza31565ze3z87_4810 =
							MAKE_FX_PROCEDURE
							(BGl_z62zc3z04anonymousza31565ze3ze5zz__threadz00, (int) (0L),
							(int) (1L));
						PROCEDURE_SET(BgL_zc3z04anonymousza31565ze3z87_4810, (int) (0L),
							BgL_threadz00_4808);
						{	/* Llib/thread.scm 535 */
							obj_t BgL_arg1921z00_4811;

							{	/* Llib/thread.scm 535 */
								obj_t BgL_arg1922z00_4812;

								BgL_arg1922z00_4812 = BGL_EXITD_PROTECT(BgL_exitd1067z00_4809);
								BgL_arg1921z00_4811 =
									MAKE_YOUNG_PAIR(BgL_zc3z04anonymousza31565ze3z87_4810,
									BgL_arg1922z00_4812);
							}
							BGL_EXITD_PROTECT_SET(BgL_exitd1067z00_4809, BgL_arg1921z00_4811);
							BUNSPEC;
						}
						{	/* Llib/thread.scm 536 */
							BgL_nothreadz00_bglt BgL_tmp1069z00_4813;

							BGl_za2nothreadzd2currentza2zd2zz__threadz00 =
								((obj_t) ((BgL_nothreadz00_bglt) BgL_thz00_3773));
							{	/* Llib/thread.scm 538 */
								obj_t BgL_env1080z00_4814;

								BgL_env1080z00_4814 = BGL_CURRENT_DYNAMIC_ENV();
								{	/* Llib/thread.scm 538 */
									obj_t BgL_cell1075z00_4815;

									BgL_cell1075z00_4815 = MAKE_STACK_CELL(BUNSPEC);
									{	/* Llib/thread.scm 538 */
										obj_t BgL_val1079z00_4816;

										BgL_val1079z00_4816 =
											BGl_zc3z04exitza31560ze3ze70z60zz__threadz00(
											((BgL_nothreadz00_bglt) BgL_thz00_3773),
											BgL_cell1075z00_4815, BgL_env1080z00_4814);
										if ((BgL_val1079z00_4816 == BgL_cell1075z00_4815))
											{	/* Llib/thread.scm 538 */
												{	/* Llib/thread.scm 538 */
													int BgL_tmpz00_6924;

													BgL_tmpz00_6924 = (int) (0L);
													BGL_SIGSETMASK(BgL_tmpz00_6924);
												}
												{	/* Llib/thread.scm 538 */
													obj_t BgL_arg1559z00_4817;

													BgL_arg1559z00_4817 =
														CELL_REF(((obj_t) BgL_val1079z00_4816));
													((((BgL_nothreadz00_bglt) COBJECT(
																	((BgL_nothreadz00_bglt) BgL_thz00_3773)))->
															BgL_endzd2exceptionzd2) =
														((obj_t) BgL_arg1559z00_4817), BUNSPEC);
													BGl_raisez00zz__errorz00(BgL_arg1559z00_4817);
											}}
										else
											{	/* Llib/thread.scm 538 */
												BgL_val1079z00_4816;
											}
									}
								}
							}
							BgL_tmp1069z00_4813 = ((BgL_nothreadz00_bglt) BgL_thz00_3773);
							{	/* Llib/thread.scm 535 */
								bool_t BgL_test2771z00_6933;

								{	/* Llib/thread.scm 535 */
									obj_t BgL_arg1920z00_4818;

									BgL_arg1920z00_4818 =
										BGL_EXITD_PROTECT(BgL_exitd1067z00_4809);
									BgL_test2771z00_6933 = PAIRP(BgL_arg1920z00_4818);
								}
								if (BgL_test2771z00_6933)
									{	/* Llib/thread.scm 535 */
										obj_t BgL_arg1917z00_4819;

										{	/* Llib/thread.scm 535 */
											obj_t BgL_arg1918z00_4820;

											BgL_arg1918z00_4820 =
												BGL_EXITD_PROTECT(BgL_exitd1067z00_4809);
											BgL_arg1917z00_4819 = CDR(((obj_t) BgL_arg1918z00_4820));
										}
										BGL_EXITD_PROTECT_SET(BgL_exitd1067z00_4809,
											BgL_arg1917z00_4819);
										BUNSPEC;
									}
								else
									{	/* Llib/thread.scm 535 */
										BFALSE;
									}
							}
							BGl_za2nothreadzd2currentza2zd2zz__threadz00 = BgL_threadz00_4808;
							return ((obj_t) BgL_tmp1069z00_4813);
						}
					}
				}
			}
		}

	}



/* <@exit:1560>~0 */
	obj_t BGl_zc3z04exitza31560ze3ze70z60zz__threadz00(BgL_nothreadz00_bglt
		BgL_i1071z00_3809, obj_t BgL_cell1075z00_3808, obj_t BgL_env1080z00_3807)
	{
		{	/* Llib/thread.scm 538 */
			jmp_buf_t jmpbuf;
			void *BgL_an_exit1084z00_1740;

			if (SET_EXIT(BgL_an_exit1084z00_1740))
				{
					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_1740 = (void *) jmpbuf;
					PUSH_ENV_EXIT(BgL_env1080z00_3807, BgL_an_exit1084z00_1740, 1L);
					{	/* Llib/thread.scm 538 */
						obj_t BgL_escape1076z00_1741;

						BgL_escape1076z00_1741 =
							BGL_ENV_EXITD_TOP_AS_OBJ(BgL_env1080z00_3807);
						{	/* Llib/thread.scm 538 */
							obj_t BgL_res1087z00_1742;

							{	/* Llib/thread.scm 538 */
								obj_t BgL_ohs1072z00_1743;

								BgL_ohs1072z00_1743 =
									BGL_ENV_ERROR_HANDLER_GET(BgL_env1080z00_3807);
								{	/* Llib/thread.scm 538 */
									obj_t BgL_hds1073z00_1744;

									BgL_hds1073z00_1744 =
										MAKE_STACK_PAIR(BgL_escape1076z00_1741,
										BgL_cell1075z00_3808);
									BGL_ENV_ERROR_HANDLER_SET(BgL_env1080z00_3807,
										BgL_hds1073z00_1744);
									BUNSPEC;
									{	/* Llib/thread.scm 538 */
										obj_t BgL_exitd1081z00_1745;

										BgL_exitd1081z00_1745 =
											BGL_ENV_EXITD_TOP_AS_OBJ(BgL_env1080z00_3807);
										{	/* Llib/thread.scm 538 */
											obj_t BgL_tmp1083z00_1746;

											{	/* Llib/thread.scm 538 */
												obj_t BgL_arg1563z00_1749;

												BgL_arg1563z00_1749 =
													BGL_EXITD_PROTECT(BgL_exitd1081z00_1745);
												BgL_tmp1083z00_1746 =
													MAKE_YOUNG_PAIR(BgL_ohs1072z00_1743,
													BgL_arg1563z00_1749);
											}
											{	/* Llib/thread.scm 538 */

												BGL_EXITD_PROTECT_SET(BgL_exitd1081z00_1745,
													BgL_tmp1083z00_1746);
												BUNSPEC;
												{	/* Llib/thread.scm 538 */
													obj_t BgL_tmp1082z00_1747;

													{
														obj_t BgL_auxz00_6952;

														{	/* Llib/thread.scm 542 */
															obj_t BgL_fun1561z00_1748;

															BgL_fun1561z00_1748 =
																(((BgL_nothreadz00_bglt)
																	COBJECT(BgL_i1071z00_3809))->BgL_bodyz00);
															BgL_auxz00_6952 =
																(VA_PROCEDUREP(BgL_fun1561z00_1748)
																? ((obj_t(*)(obj_t,
																			...))
																	PROCEDURE_ENTRY(BgL_fun1561z00_1748))
																(BgL_fun1561z00_1748,
																	BEOA) : ((obj_t(*)(obj_t))
																	PROCEDURE_ENTRY(BgL_fun1561z00_1748))
																(BgL_fun1561z00_1748));
														}
														BgL_tmp1082z00_1747 =
															((((BgL_nothreadz00_bglt)
																	COBJECT(BgL_i1071z00_3809))->
																BgL_endzd2resultzd2) =
															((obj_t) BgL_auxz00_6952), BUNSPEC);
													}
													{	/* Llib/thread.scm 538 */
														bool_t BgL_test2772z00_6958;

														{	/* Llib/thread.scm 538 */
															obj_t BgL_arg1920z00_3091;

															BgL_arg1920z00_3091 =
																BGL_EXITD_PROTECT(BgL_exitd1081z00_1745);
															BgL_test2772z00_6958 = PAIRP(BgL_arg1920z00_3091);
														}
														if (BgL_test2772z00_6958)
															{	/* Llib/thread.scm 538 */
																obj_t BgL_arg1917z00_3092;

																{	/* Llib/thread.scm 538 */
																	obj_t BgL_arg1918z00_3093;

																	BgL_arg1918z00_3093 =
																		BGL_EXITD_PROTECT(BgL_exitd1081z00_1745);
																	BgL_arg1917z00_3092 =
																		CDR(((obj_t) BgL_arg1918z00_3093));
																}
																BGL_EXITD_PROTECT_SET(BgL_exitd1081z00_1745,
																	BgL_arg1917z00_3092);
																BUNSPEC;
															}
														else
															{	/* Llib/thread.scm 538 */
																BFALSE;
															}
													}
													BGL_ENV_ERROR_HANDLER_SET(BgL_env1080z00_3807,
														BgL_ohs1072z00_1743);
													BUNSPEC;
													BgL_res1087z00_1742 = BgL_tmp1082z00_1747;
												}
											}
										}
									}
								}
							}
							POP_ENV_EXIT(BgL_env1080z00_3807);
							return BgL_res1087z00_1742;
						}
					}
				}
		}

	}



/* &<@anonymous:1565> */
	obj_t BGl_z62zc3z04anonymousza31565ze3ze5zz__threadz00(obj_t BgL_envz00_3775)
	{
		{	/* Llib/thread.scm 535 */
			{	/* Llib/thread.scm 544 */
				obj_t BgL_threadz00_3776;

				BgL_threadz00_3776 = PROCEDURE_REF(BgL_envz00_3775, (int) (0L));
				return (BGl_za2nothreadzd2currentza2zd2zz__threadz00 =
					BgL_threadz00_3776, BUNSPEC);
			}
		}

	}



/* &object-print-thread1194 */
	obj_t BGl_z62objectzd2printzd2thread1194z62zz__threadz00(obj_t
		BgL_envz00_3777, obj_t BgL_oz00_3778, obj_t BgL_portz00_3779,
		obj_t BgL_printzd2slotzd2_3780)
	{
		{	/* Llib/thread.scm 378 */
			{	/* Llib/thread.scm 379 */
				obj_t BgL_list1558z00_4822;

				BgL_list1558z00_4822 = MAKE_YOUNG_PAIR(BgL_portz00_3779, BNIL);
				return
					BGl_objectzd2writezd2zz__objectz00(
					((BgL_objectz00_bglt)
						((BgL_threadz00_bglt) BgL_oz00_3778)), BgL_list1558z00_4822);
			}
		}

	}



/* &object-write-thread1192 */
	obj_t BGl_z62objectzd2writezd2thread1192z62zz__threadz00(obj_t
		BgL_envz00_3781, obj_t BgL_oz00_3782, obj_t BgL_portz00_3783)
	{
		{	/* Llib/thread.scm 369 */
			{	/* Llib/thread.scm 370 */
				obj_t BgL_arg1544z00_4824;

				if (PAIRP(BgL_portz00_3783))
					{	/* Llib/thread.scm 370 */
						BgL_arg1544z00_4824 = CAR(BgL_portz00_3783);
					}
				else
					{	/* Llib/thread.scm 370 */
						obj_t BgL_tmpz00_6976;

						BgL_tmpz00_6976 = BGL_CURRENT_DYNAMIC_ENV();
						BgL_arg1544z00_4824 = BGL_ENV_CURRENT_OUTPUT_PORT(BgL_tmpz00_6976);
					}
				{	/* Llib/thread.scm 372 */
					obj_t BgL_zc3z04anonymousza31547ze3z87_4825;

					BgL_zc3z04anonymousza31547ze3z87_4825 =
						MAKE_FX_PROCEDURE(BGl_z62zc3z04anonymousza31547ze3ze5zz__threadz00,
						(int) (0L), (int) (1L));
					PROCEDURE_SET(BgL_zc3z04anonymousza31547ze3z87_4825,
						(int) (0L), ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3782)));
					return
						BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00
						(BgL_arg1544z00_4824, BgL_zc3z04anonymousza31547ze3z87_4825);
				}
			}
		}

	}



/* &<@anonymous:1547> */
	obj_t BGl_z62zc3z04anonymousza31547ze3ze5zz__threadz00(obj_t BgL_envz00_3784)
	{
		{	/* Llib/thread.scm 371 */
			{	/* Llib/thread.scm 372 */
				BgL_threadz00_bglt BgL_oz00_3785;

				BgL_oz00_3785 =
					((BgL_threadz00_bglt) PROCEDURE_REF(BgL_envz00_3784, (int) (0L)));
				{	/* Llib/thread.scm 373 */
					obj_t BgL_arg1548z00_4826;
					obj_t BgL_arg1550z00_4827;

					{	/* Llib/thread.scm 373 */
						obj_t BgL_arg1556z00_4828;

						{	/* Llib/thread.scm 373 */
							long BgL_arg1938z00_4829;

							{	/* Llib/thread.scm 373 */
								long BgL_arg1939z00_4830;

								BgL_arg1939z00_4830 =
									BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_3785));
								BgL_arg1938z00_4829 = (BgL_arg1939z00_4830 - OBJECT_TYPE);
							}
							BgL_arg1556z00_4828 =
								VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
								BgL_arg1938z00_4829);
						}
						BgL_arg1548z00_4826 =
							BGl_classzd2namezd2zz__objectz00(BgL_arg1556z00_4828);
					}
					BgL_arg1550z00_4827 =
						(((BgL_threadz00_bglt) COBJECT(BgL_oz00_3785))->BgL_namez00);
					{	/* Llib/thread.scm 373 */
						obj_t BgL_list1551z00_4831;

						{	/* Llib/thread.scm 373 */
							obj_t BgL_arg1552z00_4832;

							{	/* Llib/thread.scm 373 */
								obj_t BgL_arg1553z00_4833;

								{	/* Llib/thread.scm 373 */
									obj_t BgL_arg1554z00_4834;

									{	/* Llib/thread.scm 373 */
										obj_t BgL_arg1555z00_4835;

										BgL_arg1555z00_4835 =
											MAKE_YOUNG_PAIR(BGl_string2373z00zz__threadz00, BNIL);
										BgL_arg1554z00_4834 =
											MAKE_YOUNG_PAIR(BgL_arg1550z00_4827, BgL_arg1555z00_4835);
									}
									BgL_arg1553z00_4833 =
										MAKE_YOUNG_PAIR(BGl_string2374z00zz__threadz00,
										BgL_arg1554z00_4834);
								}
								BgL_arg1552z00_4832 =
									MAKE_YOUNG_PAIR(BgL_arg1548z00_4826, BgL_arg1553z00_4833);
							}
							BgL_list1551z00_4831 =
								MAKE_YOUNG_PAIR(BGl_string2375z00zz__threadz00,
								BgL_arg1552z00_4832);
						}
						return
							BGl_displayza2za2zz__r4_output_6_10_3z00(BgL_list1551z00_4831);
					}
				}
			}
		}

	}



/* &object-display-threa1190 */
	obj_t BGl_z62objectzd2displayzd2threa1190z62zz__threadz00(obj_t
		BgL_envz00_3786, obj_t BgL_oz00_3787, obj_t BgL_portz00_3788)
	{
		{	/* Llib/thread.scm 360 */
			{	/* Llib/thread.scm 361 */
				obj_t BgL_arg1523z00_4837;

				if (PAIRP(BgL_portz00_3788))
					{	/* Llib/thread.scm 361 */
						BgL_arg1523z00_4837 = CAR(BgL_portz00_3788);
					}
				else
					{	/* Llib/thread.scm 361 */
						obj_t BgL_tmpz00_7005;

						BgL_tmpz00_7005 = BGL_CURRENT_DYNAMIC_ENV();
						BgL_arg1523z00_4837 = BGL_ENV_CURRENT_OUTPUT_PORT(BgL_tmpz00_7005);
					}
				{	/* Llib/thread.scm 363 */
					obj_t BgL_zc3z04anonymousza31526ze3z87_4838;

					BgL_zc3z04anonymousza31526ze3z87_4838 =
						MAKE_FX_PROCEDURE(BGl_z62zc3z04anonymousza31526ze3ze5zz__threadz00,
						(int) (0L), (int) (1L));
					PROCEDURE_SET(BgL_zc3z04anonymousza31526ze3z87_4838,
						(int) (0L), ((obj_t) ((BgL_threadz00_bglt) BgL_oz00_3787)));
					return
						BGl_withzd2outputzd2tozd2portzd2zz__r4_ports_6_10_1z00
						(BgL_arg1523z00_4837, BgL_zc3z04anonymousza31526ze3z87_4838);
				}
			}
		}

	}



/* &<@anonymous:1526> */
	obj_t BGl_z62zc3z04anonymousza31526ze3ze5zz__threadz00(obj_t BgL_envz00_3789)
	{
		{	/* Llib/thread.scm 362 */
			{	/* Llib/thread.scm 363 */
				BgL_threadz00_bglt BgL_oz00_3790;

				BgL_oz00_3790 =
					((BgL_threadz00_bglt) PROCEDURE_REF(BgL_envz00_3789, (int) (0L)));
				{	/* Llib/thread.scm 364 */
					obj_t BgL_arg1528z00_4839;
					obj_t BgL_arg1531z00_4840;

					{	/* Llib/thread.scm 364 */
						obj_t BgL_arg1542z00_4841;

						{	/* Llib/thread.scm 364 */
							long BgL_arg1938z00_4842;

							{	/* Llib/thread.scm 364 */
								long BgL_arg1939z00_4843;

								BgL_arg1939z00_4843 =
									BGL_OBJECT_CLASS_NUM(((BgL_objectz00_bglt) BgL_oz00_3790));
								BgL_arg1938z00_4842 = (BgL_arg1939z00_4843 - OBJECT_TYPE);
							}
							BgL_arg1542z00_4841 =
								VECTOR_REF(BGl_za2classesza2z00zz__objectz00,
								BgL_arg1938z00_4842);
						}
						BgL_arg1528z00_4839 =
							BGl_classzd2namezd2zz__objectz00(BgL_arg1542z00_4841);
					}
					BgL_arg1531z00_4840 =
						(((BgL_threadz00_bglt) COBJECT(BgL_oz00_3790))->BgL_namez00);
					{	/* Llib/thread.scm 364 */
						obj_t BgL_list1532z00_4844;

						{	/* Llib/thread.scm 364 */
							obj_t BgL_arg1534z00_4845;

							{	/* Llib/thread.scm 364 */
								obj_t BgL_arg1535z00_4846;

								{	/* Llib/thread.scm 364 */
									obj_t BgL_arg1536z00_4847;

									{	/* Llib/thread.scm 364 */
										obj_t BgL_arg1541z00_4848;

										BgL_arg1541z00_4848 =
											MAKE_YOUNG_PAIR(BGl_string2373z00zz__threadz00, BNIL);
										BgL_arg1536z00_4847 =
											MAKE_YOUNG_PAIR(BgL_arg1531z00_4840, BgL_arg1541z00_4848);
									}
									BgL_arg1535z00_4846 =
										MAKE_YOUNG_PAIR(BGl_string2374z00zz__threadz00,
										BgL_arg1536z00_4847);
								}
								BgL_arg1534z00_4845 =
									MAKE_YOUNG_PAIR(BgL_arg1528z00_4839, BgL_arg1535z00_4846);
							}
							BgL_list1532z00_4844 =
								MAKE_YOUNG_PAIR(BGl_string2375z00zz__threadz00,
								BgL_arg1534z00_4845);
						}
						return
							BGl_displayza2za2zz__r4_output_6_10_3z00(BgL_list1532z00_4844);
					}
				}
			}
		}

	}



/* &tb-current-thread-no1184 */
	obj_t BGl_z62tbzd2currentzd2threadzd2no1184zb0zz__threadz00(obj_t
		BgL_envz00_3791, obj_t BgL_tbz00_3792)
	{
		{	/* Llib/thread.scm 344 */
			return BGl_za2nothreadzd2currentza2zd2zz__threadz00;
		}

	}



/* &tb-make-thread-nothr1182 */
	BgL_threadz00_bglt BGl_z62tbzd2makezd2threadzd2nothr1182zb0zz__threadz00(obj_t
		BgL_envz00_3793, obj_t BgL_tbz00_3794, obj_t BgL_bodyz00_3795,
		obj_t BgL_namez00_3796)
	{
		{	/* Llib/thread.scm 336 */
			{	/* Llib/thread.scm 337 */
				BgL_nothreadz00_bglt BgL_new1062z00_4851;

				{	/* Llib/thread.scm 339 */
					BgL_nothreadz00_bglt BgL_new1060z00_4852;

					BgL_new1060z00_4852 =
						((BgL_nothreadz00_bglt) BOBJECT(GC_MALLOC(sizeof(struct
									BgL_nothreadz00_bgl))));
					{	/* Llib/thread.scm 339 */
						long BgL_arg1522z00_4853;

						BgL_arg1522z00_4853 = BGL_CLASS_NUM(BGl_nothreadz00zz__threadz00);
						BGL_OBJECT_CLASS_NUM_SET(
							((BgL_objectz00_bglt) BgL_new1060z00_4852), BgL_arg1522z00_4853);
					}
					BgL_new1062z00_4851 = BgL_new1060z00_4852;
				}
				((((BgL_threadz00_bglt) COBJECT(
								((BgL_threadz00_bglt) BgL_new1062z00_4851)))->BgL_namez00) =
					((obj_t) BgL_namez00_3796), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->BgL_bodyz00) =
					((obj_t) BgL_bodyz00_3795), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->
						BgL_z52specificz52) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->
						BgL_z52cleanupz52) = ((obj_t) BFALSE), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->
						BgL_endzd2resultzd2) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->
						BgL_endzd2exceptionzd2) = ((obj_t) BUNSPEC), BUNSPEC);
				((((BgL_nothreadz00_bglt) COBJECT(BgL_new1062z00_4851))->
						BgL_z52namez52) =
					((obj_t) BGl_string2264z00zz__threadz00), BUNSPEC);
				{	/* Llib/thread.scm 337 */
					obj_t BgL_fun1521z00_4854;

					BgL_fun1521z00_4854 =
						BGl_classzd2constructorzd2zz__objectz00
						(BGl_nothreadz00zz__threadz00);
					(VA_PROCEDUREP(BgL_fun1521z00_4854) ? ((obj_t(*)(obj_t,
									...))
							PROCEDURE_ENTRY(BgL_fun1521z00_4854)) (BgL_fun1521z00_4854,
							((obj_t) BgL_new1062z00_4851), BEOA) : ((obj_t(*)(obj_t,
									obj_t))
							PROCEDURE_ENTRY(BgL_fun1521z00_4854)) (BgL_fun1521z00_4854,
							((obj_t) BgL_new1062z00_4851)));
				}
				return ((BgL_threadz00_bglt) BgL_new1062z00_4851);
			}
		}

	}



/* imported-modules-init */
	obj_t BGl_importedzd2moduleszd2initz00zz__threadz00(void)
	{
		{	/* Llib/thread.scm 17 */
			BGl_modulezd2initializa7ationz75zz__errorz00(88804785L,
				BSTRING_TO_STRING(BGl_string2204z00zz__threadz00));
			return
				BGl_modulezd2initializa7ationz75zz__objectz00(475449627L,
				BSTRING_TO_STRING(BGl_string2204z00zz__threadz00));
		}

	}

#ifdef __cplusplus
}
#endif
