# Generated automatically by gen-auto-xsh
#
# Source files:
#   /usr/include/allegro/3d.h
#   /usr/include/allegro/3dmaths.h
#   /usr/include/allegro/alcompat.h
#   /usr/include/allegro/alinline.h
#   /usr/include/allegro/alunixac.h
#   /usr/include/allegro/base.h
#   /usr/include/allegro/color.h
#   /usr/include/allegro/compiled.h
#   /usr/include/allegro/config.h
#   /usr/include/allegro/datafile.h
#   /usr/include/allegro/debug.h
#   /usr/include/allegro/digi.h
#   /usr/include/allegro/draw.h
#   /usr/include/allegro/file.h
#   /usr/include/allegro/fix.h
#   /usr/include/allegro/fixed.h
#   /usr/include/allegro/fli.h
#   /usr/include/allegro/fmaths.h
#   /usr/include/allegro/gfx.h
#   /usr/include/allegro/gui.h
#   /usr/include/allegro/joystick.h
#   /usr/include/allegro/keyboard.h
#   /usr/include/allegro/matrix.h
#   /usr/include/allegro/midi.h
#   /usr/include/allegro/mouse.h
#   /usr/include/allegro/palette.h
#   /usr/include/allegro/quat.h
#   /usr/include/allegro/rle.h
#   /usr/include/allegro/sound.h
#   /usr/include/allegro/stream.h
#   /usr/include/allegro/system.h
#   /usr/include/allegro/text.h
#   /usr/include/allegro/timer.h
#   /usr/include/allegro/unicode.h
#   /usr/include/allegro/inline/3dmaths.inl
#   /usr/include/allegro/inline/asm.inl
#   /usr/include/allegro/inline/color.inl
#   /usr/include/allegro/inline/draw.inl
#   /usr/include/allegro/inline/file.inl
#   /usr/include/allegro/inline/fix.inl
#   /usr/include/allegro/inline/fmaths.inl
#   /usr/include/allegro/inline/gfx.inl
#   /usr/include/allegro/inline/gui.inl
#   /usr/include/allegro/inline/matrix.inl
#   /usr/include/allegro/inline/rle.inl
#   /usr/include/allegro/inline/system.inl
#

int
AL_COLORCONV_15_TO_16()
   CODE:
      RETVAL = COLORCONV_15_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_15_TO_24()
   CODE:
      RETVAL = COLORCONV_15_TO_24;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_15_TO_32()
   CODE:
      RETVAL = COLORCONV_15_TO_32;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_15_TO_8()
   CODE:
      RETVAL = COLORCONV_15_TO_8;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_16_TO_15()
   CODE:
      RETVAL = COLORCONV_16_TO_15;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_16_TO_24()
   CODE:
      RETVAL = COLORCONV_16_TO_24;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_16_TO_32()
   CODE:
      RETVAL = COLORCONV_16_TO_32;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_16_TO_8()
   CODE:
      RETVAL = COLORCONV_16_TO_8;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_24_TO_15()
   CODE:
      RETVAL = COLORCONV_24_TO_15;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_24_TO_16()
   CODE:
      RETVAL = COLORCONV_24_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_24_TO_32()
   CODE:
      RETVAL = COLORCONV_24_TO_32;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_24_TO_8()
   CODE:
      RETVAL = COLORCONV_24_TO_8;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32A_TO_15()
   CODE:
      RETVAL = COLORCONV_32A_TO_15;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32A_TO_16()
   CODE:
      RETVAL = COLORCONV_32A_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32A_TO_24()
   CODE:
      RETVAL = COLORCONV_32A_TO_24;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32A_TO_8()
   CODE:
      RETVAL = COLORCONV_32A_TO_8;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32_TO_15()
   CODE:
      RETVAL = COLORCONV_32_TO_15;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32_TO_16()
   CODE:
      RETVAL = COLORCONV_32_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32_TO_24()
   CODE:
      RETVAL = COLORCONV_32_TO_24;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_32_TO_8()
   CODE:
      RETVAL = COLORCONV_32_TO_8;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_8_TO_15()
   CODE:
      RETVAL = COLORCONV_8_TO_15;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_8_TO_16()
   CODE:
      RETVAL = COLORCONV_8_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_8_TO_24()
   CODE:
      RETVAL = COLORCONV_8_TO_24;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_8_TO_32()
   CODE:
      RETVAL = COLORCONV_8_TO_32;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_DITHER_HI()
   CODE:
      RETVAL = COLORCONV_DITHER_HI;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_DITHER_PAL()
   CODE:
      RETVAL = COLORCONV_DITHER_PAL;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_EXPAND_15_TO_16()
   CODE:
      RETVAL = COLORCONV_EXPAND_15_TO_16;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_KEEP_TRANS()
   CODE:
      RETVAL = COLORCONV_KEEP_TRANS;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_NONE()
   CODE:
      RETVAL = COLORCONV_NONE;
   OUTPUT:
      RETVAL


int
AL_COLORCONV_REDUCE_16_TO_15()
   CODE:
      RETVAL = COLORCONV_REDUCE_16_TO_15;
   OUTPUT:
      RETVAL


int
AL_DAT_BITMAP()
   CODE:
      RETVAL = DAT_BITMAP;
   OUTPUT:
      RETVAL


int
AL_DAT_C_SPRITE()
   CODE:
      RETVAL = DAT_C_SPRITE;
   OUTPUT:
      RETVAL


int
AL_DAT_DATA()
   CODE:
      RETVAL = DAT_DATA;
   OUTPUT:
      RETVAL


int
AL_DAT_END()
   CODE:
      RETVAL = DAT_END;
   OUTPUT:
      RETVAL


int
AL_DAT_FILE()
   CODE:
      RETVAL = DAT_FILE;
   OUTPUT:
      RETVAL


int
AL_DAT_FLI()
   CODE:
      RETVAL = DAT_FLI;
   OUTPUT:
      RETVAL


int
AL_DAT_FONT()
   CODE:
      RETVAL = DAT_FONT;
   OUTPUT:
      RETVAL


int
AL_DAT_MAGIC()
   CODE:
      RETVAL = DAT_MAGIC;
   OUTPUT:
      RETVAL


int
AL_DAT_MIDI()
   CODE:
      RETVAL = DAT_MIDI;
   OUTPUT:
      RETVAL


int
AL_DAT_NAME()
   CODE:
      RETVAL = DAT_NAME;
   OUTPUT:
      RETVAL


int
AL_DAT_PALETTE()
   CODE:
      RETVAL = DAT_PALETTE;
   OUTPUT:
      RETVAL


int
AL_DAT_PALLETE()
   CODE:
      RETVAL = DAT_PALLETE;
   OUTPUT:
      RETVAL


int
AL_DAT_PATCH()
   CODE:
      RETVAL = DAT_PATCH;
   OUTPUT:
      RETVAL


int
AL_DAT_PROPERTY()
   CODE:
      RETVAL = DAT_PROPERTY;
   OUTPUT:
      RETVAL


int
AL_DAT_RLE_SPRITE()
   CODE:
      RETVAL = DAT_RLE_SPRITE;
   OUTPUT:
      RETVAL


int
AL_DAT_SAMPLE()
   CODE:
      RETVAL = DAT_SAMPLE;
   OUTPUT:
      RETVAL


int
AL_DAT_XC_SPRITE()
   CODE:
      RETVAL = DAT_XC_SPRITE;
   OUTPUT:
      RETVAL


int
AL_DIGI_AUTODETECT()
   CODE:
      RETVAL = DIGI_AUTODETECT;
   OUTPUT:
      RETVAL


int
AL_DIGI_NONE()
   CODE:
      RETVAL = DIGI_NONE;
   OUTPUT:
      RETVAL


int
AL_DIGI_VOICES()
   CODE:
      RETVAL = DIGI_VOICES;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_COPY_PATTERN()
   CODE:
      RETVAL = DRAW_MODE_COPY_PATTERN;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_MASKED_PATTERN()
   CODE:
      RETVAL = DRAW_MODE_MASKED_PATTERN;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_SOLID()
   CODE:
      RETVAL = DRAW_MODE_SOLID;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_SOLID_PATTERN()
   CODE:
      RETVAL = DRAW_MODE_SOLID_PATTERN;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_TRANS()
   CODE:
      RETVAL = DRAW_MODE_TRANS;
   OUTPUT:
      RETVAL


int
AL_DRAW_MODE_XOR()
   CODE:
      RETVAL = DRAW_MODE_XOR;
   OUTPUT:
      RETVAL


int
AL_GFX_AUTODETECT()
   CODE:
      RETVAL = GFX_AUTODETECT;
   OUTPUT:
      RETVAL


int
AL_GFX_AUTODETECT_FULLSCREEN()
   CODE:
      RETVAL = GFX_AUTODETECT_FULLSCREEN;
   OUTPUT:
      RETVAL


int
AL_GFX_AUTODETECT_WINDOWED()
   CODE:
      RETVAL = GFX_AUTODETECT_WINDOWED;
   OUTPUT:
      RETVAL


int
AL_GFX_CAN_SCROLL()
   CODE:
      RETVAL = GFX_CAN_SCROLL;
   OUTPUT:
      RETVAL


int
AL_GFX_CAN_TRIPLE_BUFFER()
   CODE:
      RETVAL = GFX_CAN_TRIPLE_BUFFER;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_CURSOR()
   CODE:
      RETVAL = GFX_HW_CURSOR;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_FILL()
   CODE:
      RETVAL = GFX_HW_FILL;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_FILL_COPY_PATTERN()
   CODE:
      RETVAL = GFX_HW_FILL_COPY_PATTERN;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_FILL_SOLID_PATTERN()
   CODE:
      RETVAL = GFX_HW_FILL_SOLID_PATTERN;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_FILL_XOR()
   CODE:
      RETVAL = GFX_HW_FILL_XOR;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_GLYPH()
   CODE:
      RETVAL = GFX_HW_GLYPH;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_HLINE()
   CODE:
      RETVAL = GFX_HW_HLINE;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_HLINE_COPY_PATTERN()
   CODE:
      RETVAL = GFX_HW_HLINE_COPY_PATTERN;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_HLINE_SOLID_PATTERN()
   CODE:
      RETVAL = GFX_HW_HLINE_SOLID_PATTERN;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_HLINE_XOR()
   CODE:
      RETVAL = GFX_HW_HLINE_XOR;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_LINE()
   CODE:
      RETVAL = GFX_HW_LINE;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_LINE_XOR()
   CODE:
      RETVAL = GFX_HW_LINE_XOR;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_MEM_BLIT()
   CODE:
      RETVAL = GFX_HW_MEM_BLIT;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_MEM_BLIT_MASKED()
   CODE:
      RETVAL = GFX_HW_MEM_BLIT_MASKED;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_SYS_TO_VRAM_BLIT()
   CODE:
      RETVAL = GFX_HW_SYS_TO_VRAM_BLIT;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_SYS_TO_VRAM_BLIT_MASKED()
   CODE:
      RETVAL = GFX_HW_SYS_TO_VRAM_BLIT_MASKED;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_TRIANGLE()
   CODE:
      RETVAL = GFX_HW_TRIANGLE;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_TRIANGLE_XOR()
   CODE:
      RETVAL = GFX_HW_TRIANGLE_XOR;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_VRAM_BLIT()
   CODE:
      RETVAL = GFX_HW_VRAM_BLIT;
   OUTPUT:
      RETVAL


int
AL_GFX_HW_VRAM_BLIT_MASKED()
   CODE:
      RETVAL = GFX_HW_VRAM_BLIT_MASKED;
   OUTPUT:
      RETVAL


int
AL_GFX_SAFE()
   CODE:
      RETVAL = GFX_SAFE;
   OUTPUT:
      RETVAL


int
AL_GFX_TEXT()
   CODE:
      RETVAL = GFX_TEXT;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_ANALOGUE()
   CODE:
      RETVAL = JOYFLAG_ANALOGUE;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_CALIBRATE()
   CODE:
      RETVAL = JOYFLAG_CALIBRATE;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_CALIB_ANALOGUE()
   CODE:
      RETVAL = JOYFLAG_CALIB_ANALOGUE;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_CALIB_DIGITAL()
   CODE:
      RETVAL = JOYFLAG_CALIB_DIGITAL;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_DIGITAL()
   CODE:
      RETVAL = JOYFLAG_DIGITAL;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_SIGNED()
   CODE:
      RETVAL = JOYFLAG_SIGNED;
   OUTPUT:
      RETVAL


int
AL_JOYFLAG_UNSIGNED()
   CODE:
      RETVAL = JOYFLAG_UNSIGNED;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_CENTER()
   CODE:
      RETVAL = JOY_HAT_CENTER;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_CENTRE()
   CODE:
      RETVAL = JOY_HAT_CENTRE;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_DOWN()
   CODE:
      RETVAL = JOY_HAT_DOWN;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_LEFT()
   CODE:
      RETVAL = JOY_HAT_LEFT;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_RIGHT()
   CODE:
      RETVAL = JOY_HAT_RIGHT;
   OUTPUT:
      RETVAL


int
AL_JOY_HAT_UP()
   CODE:
      RETVAL = JOY_HAT_UP;
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_AUTODETECT()
   CODE:
      RETVAL = JOY_TYPE_AUTODETECT;
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_NONE()
   CODE:
      RETVAL = JOY_TYPE_NONE;
   OUTPUT:
      RETVAL


int
AL_KB_ACCENT1_FLAG()
   CODE:
      RETVAL = KB_ACCENT1_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_ACCENT2_FLAG()
   CODE:
      RETVAL = KB_ACCENT2_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_ACCENT3_FLAG()
   CODE:
      RETVAL = KB_ACCENT3_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_ACCENT4_FLAG()
   CODE:
      RETVAL = KB_ACCENT4_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_ALT_FLAG()
   CODE:
      RETVAL = KB_ALT_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_CAPSLOCK_FLAG()
   CODE:
      RETVAL = KB_CAPSLOCK_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_CTRL_FLAG()
   CODE:
      RETVAL = KB_CTRL_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_EXTENDED()
   CODE:
      RETVAL = KB_EXTENDED;
   OUTPUT:
      RETVAL


int
AL_KB_INALTSEQ_FLAG()
   CODE:
      RETVAL = KB_INALTSEQ_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_LWIN_FLAG()
   CODE:
      RETVAL = KB_LWIN_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_MENU_FLAG()
   CODE:
      RETVAL = KB_MENU_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_NORMAL()
   CODE:
      RETVAL = KB_NORMAL;
   OUTPUT:
      RETVAL


int
AL_KB_NUMLOCK_FLAG()
   CODE:
      RETVAL = KB_NUMLOCK_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_RWIN_FLAG()
   CODE:
      RETVAL = KB_RWIN_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_SCROLOCK_FLAG()
   CODE:
      RETVAL = KB_SCROLOCK_FLAG;
   OUTPUT:
      RETVAL


int
AL_KB_SHIFT_FLAG()
   CODE:
      RETVAL = KB_SHIFT_FLAG;
   OUTPUT:
      RETVAL


int
AL_KEY_0()
   CODE:
      RETVAL = KEY_0;
   OUTPUT:
      RETVAL


int
AL_KEY_0_PAD()
   CODE:
      RETVAL = KEY_0_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_1()
   CODE:
      RETVAL = KEY_1;
   OUTPUT:
      RETVAL


int
AL_KEY_1_PAD()
   CODE:
      RETVAL = KEY_1_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_2()
   CODE:
      RETVAL = KEY_2;
   OUTPUT:
      RETVAL


int
AL_KEY_2_PAD()
   CODE:
      RETVAL = KEY_2_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_3()
   CODE:
      RETVAL = KEY_3;
   OUTPUT:
      RETVAL


int
AL_KEY_3_PAD()
   CODE:
      RETVAL = KEY_3_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_4()
   CODE:
      RETVAL = KEY_4;
   OUTPUT:
      RETVAL


int
AL_KEY_4_PAD()
   CODE:
      RETVAL = KEY_4_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_5()
   CODE:
      RETVAL = KEY_5;
   OUTPUT:
      RETVAL


int
AL_KEY_5_PAD()
   CODE:
      RETVAL = KEY_5_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_6()
   CODE:
      RETVAL = KEY_6;
   OUTPUT:
      RETVAL


int
AL_KEY_6_PAD()
   CODE:
      RETVAL = KEY_6_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_7()
   CODE:
      RETVAL = KEY_7;
   OUTPUT:
      RETVAL


int
AL_KEY_7_PAD()
   CODE:
      RETVAL = KEY_7_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_8()
   CODE:
      RETVAL = KEY_8;
   OUTPUT:
      RETVAL


int
AL_KEY_8_PAD()
   CODE:
      RETVAL = KEY_8_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_9()
   CODE:
      RETVAL = KEY_9;
   OUTPUT:
      RETVAL


int
AL_KEY_9_PAD()
   CODE:
      RETVAL = KEY_9_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_A()
   CODE:
      RETVAL = KEY_A;
   OUTPUT:
      RETVAL


int
AL_KEY_ABNT_C1()
   CODE:
      RETVAL = KEY_ABNT_C1;
   OUTPUT:
      RETVAL


int
AL_KEY_ALT()
   CODE:
      RETVAL = KEY_ALT;
   OUTPUT:
      RETVAL


int
AL_KEY_ALTGR()
   CODE:
      RETVAL = KEY_ALTGR;
   OUTPUT:
      RETVAL


int
AL_KEY_ASTERISK()
   CODE:
      RETVAL = KEY_ASTERISK;
   OUTPUT:
      RETVAL


int
AL_KEY_AT()
   CODE:
      RETVAL = KEY_AT;
   OUTPUT:
      RETVAL


int
AL_KEY_B()
   CODE:
      RETVAL = KEY_B;
   OUTPUT:
      RETVAL


int
AL_KEY_BACKSLASH()
   CODE:
      RETVAL = KEY_BACKSLASH;
   OUTPUT:
      RETVAL


int
AL_KEY_BACKSLASH2()
   CODE:
      RETVAL = KEY_BACKSLASH2;
   OUTPUT:
      RETVAL


int
AL_KEY_BACKSPACE()
   CODE:
      RETVAL = KEY_BACKSPACE;
   OUTPUT:
      RETVAL


int
AL_KEY_C()
   CODE:
      RETVAL = KEY_C;
   OUTPUT:
      RETVAL


int
AL_KEY_CAPSLOCK()
   CODE:
      RETVAL = KEY_CAPSLOCK;
   OUTPUT:
      RETVAL


int
AL_KEY_CIRCUMFLEX()
   CODE:
      RETVAL = KEY_CIRCUMFLEX;
   OUTPUT:
      RETVAL


int
AL_KEY_CLOSEBRACE()
   CODE:
      RETVAL = KEY_CLOSEBRACE;
   OUTPUT:
      RETVAL


int
AL_KEY_COLON()
   CODE:
      RETVAL = KEY_COLON;
   OUTPUT:
      RETVAL


int
AL_KEY_COLON2()
   CODE:
      RETVAL = KEY_COLON2;
   OUTPUT:
      RETVAL


int
AL_KEY_COMMA()
   CODE:
      RETVAL = KEY_COMMA;
   OUTPUT:
      RETVAL


int
AL_KEY_CONVERT()
   CODE:
      RETVAL = KEY_CONVERT;
   OUTPUT:
      RETVAL


int
AL_KEY_D()
   CODE:
      RETVAL = KEY_D;
   OUTPUT:
      RETVAL


int
AL_KEY_DEL()
   CODE:
      RETVAL = KEY_DEL;
   OUTPUT:
      RETVAL


int
AL_KEY_DEL_PAD()
   CODE:
      RETVAL = KEY_DEL_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_DOWN()
   CODE:
      RETVAL = KEY_DOWN;
   OUTPUT:
      RETVAL


int
AL_KEY_E()
   CODE:
      RETVAL = KEY_E;
   OUTPUT:
      RETVAL


int
AL_KEY_END()
   CODE:
      RETVAL = KEY_END;
   OUTPUT:
      RETVAL


int
AL_KEY_ENTER()
   CODE:
      RETVAL = KEY_ENTER;
   OUTPUT:
      RETVAL


int
AL_KEY_ENTER_PAD()
   CODE:
      RETVAL = KEY_ENTER_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_EQUALS()
   CODE:
      RETVAL = KEY_EQUALS;
   OUTPUT:
      RETVAL


int
AL_KEY_ESC()
   CODE:
      RETVAL = KEY_ESC;
   OUTPUT:
      RETVAL


int
AL_KEY_F()
   CODE:
      RETVAL = KEY_F;
   OUTPUT:
      RETVAL


int
AL_KEY_F1()
   CODE:
      RETVAL = KEY_F1;
   OUTPUT:
      RETVAL


int
AL_KEY_F10()
   CODE:
      RETVAL = KEY_F10;
   OUTPUT:
      RETVAL


int
AL_KEY_F11()
   CODE:
      RETVAL = KEY_F11;
   OUTPUT:
      RETVAL


int
AL_KEY_F12()
   CODE:
      RETVAL = KEY_F12;
   OUTPUT:
      RETVAL


int
AL_KEY_F2()
   CODE:
      RETVAL = KEY_F2;
   OUTPUT:
      RETVAL


int
AL_KEY_F3()
   CODE:
      RETVAL = KEY_F3;
   OUTPUT:
      RETVAL


int
AL_KEY_F4()
   CODE:
      RETVAL = KEY_F4;
   OUTPUT:
      RETVAL


int
AL_KEY_F5()
   CODE:
      RETVAL = KEY_F5;
   OUTPUT:
      RETVAL


int
AL_KEY_F6()
   CODE:
      RETVAL = KEY_F6;
   OUTPUT:
      RETVAL


int
AL_KEY_F7()
   CODE:
      RETVAL = KEY_F7;
   OUTPUT:
      RETVAL


int
AL_KEY_F8()
   CODE:
      RETVAL = KEY_F8;
   OUTPUT:
      RETVAL


int
AL_KEY_F9()
   CODE:
      RETVAL = KEY_F9;
   OUTPUT:
      RETVAL


int
AL_KEY_G()
   CODE:
      RETVAL = KEY_G;
   OUTPUT:
      RETVAL


int
AL_KEY_H()
   CODE:
      RETVAL = KEY_H;
   OUTPUT:
      RETVAL


int
AL_KEY_HOME()
   CODE:
      RETVAL = KEY_HOME;
   OUTPUT:
      RETVAL


int
AL_KEY_I()
   CODE:
      RETVAL = KEY_I;
   OUTPUT:
      RETVAL


int
AL_KEY_INSERT()
   CODE:
      RETVAL = KEY_INSERT;
   OUTPUT:
      RETVAL


int
AL_KEY_J()
   CODE:
      RETVAL = KEY_J;
   OUTPUT:
      RETVAL


int
AL_KEY_K()
   CODE:
      RETVAL = KEY_K;
   OUTPUT:
      RETVAL


int
AL_KEY_KANA()
   CODE:
      RETVAL = KEY_KANA;
   OUTPUT:
      RETVAL


int
AL_KEY_KANJI()
   CODE:
      RETVAL = KEY_KANJI;
   OUTPUT:
      RETVAL


int
AL_KEY_L()
   CODE:
      RETVAL = KEY_L;
   OUTPUT:
      RETVAL


int
AL_KEY_LCONTROL()
   CODE:
      RETVAL = KEY_LCONTROL;
   OUTPUT:
      RETVAL


int
AL_KEY_LEFT()
   CODE:
      RETVAL = KEY_LEFT;
   OUTPUT:
      RETVAL


int
AL_KEY_LSHIFT()
   CODE:
      RETVAL = KEY_LSHIFT;
   OUTPUT:
      RETVAL


int
AL_KEY_LWIN()
   CODE:
      RETVAL = KEY_LWIN;
   OUTPUT:
      RETVAL


int
AL_KEY_M()
   CODE:
      RETVAL = KEY_M;
   OUTPUT:
      RETVAL


int
AL_KEY_MAX()
   CODE:
      RETVAL = KEY_MAX;
   OUTPUT:
      RETVAL


int
AL_KEY_MENU()
   CODE:
      RETVAL = KEY_MENU;
   OUTPUT:
      RETVAL


int
AL_KEY_MINUS()
   CODE:
      RETVAL = KEY_MINUS;
   OUTPUT:
      RETVAL


int
AL_KEY_MINUS_PAD()
   CODE:
      RETVAL = KEY_MINUS_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_MODIFIERS()
   CODE:
      RETVAL = KEY_MODIFIERS;
   OUTPUT:
      RETVAL


int
AL_KEY_N()
   CODE:
      RETVAL = KEY_N;
   OUTPUT:
      RETVAL


int
AL_KEY_NOCONVERT()
   CODE:
      RETVAL = KEY_NOCONVERT;
   OUTPUT:
      RETVAL


int
AL_KEY_NUMLOCK()
   CODE:
      RETVAL = KEY_NUMLOCK;
   OUTPUT:
      RETVAL


int
AL_KEY_O()
   CODE:
      RETVAL = KEY_O;
   OUTPUT:
      RETVAL


int
AL_KEY_OPENBRACE()
   CODE:
      RETVAL = KEY_OPENBRACE;
   OUTPUT:
      RETVAL


int
AL_KEY_P()
   CODE:
      RETVAL = KEY_P;
   OUTPUT:
      RETVAL


int
AL_KEY_PAUSE()
   CODE:
      RETVAL = KEY_PAUSE;
   OUTPUT:
      RETVAL


int
AL_KEY_PGDN()
   CODE:
      RETVAL = KEY_PGDN;
   OUTPUT:
      RETVAL


int
AL_KEY_PGUP()
   CODE:
      RETVAL = KEY_PGUP;
   OUTPUT:
      RETVAL


int
AL_KEY_PLUS_PAD()
   CODE:
      RETVAL = KEY_PLUS_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_PRTSCR()
   CODE:
      RETVAL = KEY_PRTSCR;
   OUTPUT:
      RETVAL


int
AL_KEY_Q()
   CODE:
      RETVAL = KEY_Q;
   OUTPUT:
      RETVAL


int
AL_KEY_QUOTE()
   CODE:
      RETVAL = KEY_QUOTE;
   OUTPUT:
      RETVAL


int
AL_KEY_R()
   CODE:
      RETVAL = KEY_R;
   OUTPUT:
      RETVAL


int
AL_KEY_RCONTROL()
   CODE:
      RETVAL = KEY_RCONTROL;
   OUTPUT:
      RETVAL


int
AL_KEY_RIGHT()
   CODE:
      RETVAL = KEY_RIGHT;
   OUTPUT:
      RETVAL


int
AL_KEY_RSHIFT()
   CODE:
      RETVAL = KEY_RSHIFT;
   OUTPUT:
      RETVAL


int
AL_KEY_RWIN()
   CODE:
      RETVAL = KEY_RWIN;
   OUTPUT:
      RETVAL


int
AL_KEY_S()
   CODE:
      RETVAL = KEY_S;
   OUTPUT:
      RETVAL


int
AL_KEY_SCRLOCK()
   CODE:
      RETVAL = KEY_SCRLOCK;
   OUTPUT:
      RETVAL


int
AL_KEY_SLASH()
   CODE:
      RETVAL = KEY_SLASH;
   OUTPUT:
      RETVAL


int
AL_KEY_SLASH_PAD()
   CODE:
      RETVAL = KEY_SLASH_PAD;
   OUTPUT:
      RETVAL


int
AL_KEY_SPACE()
   CODE:
      RETVAL = KEY_SPACE;
   OUTPUT:
      RETVAL


int
AL_KEY_STOP()
   CODE:
      RETVAL = KEY_STOP;
   OUTPUT:
      RETVAL


int
AL_KEY_T()
   CODE:
      RETVAL = KEY_T;
   OUTPUT:
      RETVAL


int
AL_KEY_TAB()
   CODE:
      RETVAL = KEY_TAB;
   OUTPUT:
      RETVAL


int
AL_KEY_TILDE()
   CODE:
      RETVAL = KEY_TILDE;
   OUTPUT:
      RETVAL


int
AL_KEY_U()
   CODE:
      RETVAL = KEY_U;
   OUTPUT:
      RETVAL


int
AL_KEY_UP()
   CODE:
      RETVAL = KEY_UP;
   OUTPUT:
      RETVAL


int
AL_KEY_V()
   CODE:
      RETVAL = KEY_V;
   OUTPUT:
      RETVAL


int
AL_KEY_W()
   CODE:
      RETVAL = KEY_W;
   OUTPUT:
      RETVAL


int
AL_KEY_X()
   CODE:
      RETVAL = KEY_X;
   OUTPUT:
      RETVAL


int
AL_KEY_Y()
   CODE:
      RETVAL = KEY_Y;
   OUTPUT:
      RETVAL


int
AL_KEY_YEN()
   CODE:
      RETVAL = KEY_YEN;
   OUTPUT:
      RETVAL


int
AL_KEY_Z()
   CODE:
      RETVAL = KEY_Z;
   OUTPUT:
      RETVAL


int
AL_MASK_COLOR_15()
   CODE:
      RETVAL = MASK_COLOR_15;
   OUTPUT:
      RETVAL


int
AL_MASK_COLOR_16()
   CODE:
      RETVAL = MASK_COLOR_16;
   OUTPUT:
      RETVAL


int
AL_MASK_COLOR_24()
   CODE:
      RETVAL = MASK_COLOR_24;
   OUTPUT:
      RETVAL


int
AL_MASK_COLOR_32()
   CODE:
      RETVAL = MASK_COLOR_32;
   OUTPUT:
      RETVAL


int
AL_MASK_COLOR_8()
   CODE:
      RETVAL = MASK_COLOR_8;
   OUTPUT:
      RETVAL


int
AL_MIDI_AUTODETECT()
   CODE:
      RETVAL = MIDI_AUTODETECT;
   OUTPUT:
      RETVAL


int
AL_MIDI_DIGMID()
   CODE:
      RETVAL = MIDI_DIGMID;
   OUTPUT:
      RETVAL


int
AL_MIDI_NONE()
   CODE:
      RETVAL = MIDI_NONE;
   OUTPUT:
      RETVAL


int
AL_MIDI_TRACKS()
   CODE:
      RETVAL = MIDI_TRACKS;
   OUTPUT:
      RETVAL


int
AL_MIDI_VOICES()
   CODE:
      RETVAL = MIDI_VOICES;
   OUTPUT:
      RETVAL


int
AL_PLAYMODE_BACKWARD()
   CODE:
      RETVAL = PLAYMODE_BACKWARD;
   OUTPUT:
      RETVAL


int
AL_PLAYMODE_BIDIR()
   CODE:
      RETVAL = PLAYMODE_BIDIR;
   OUTPUT:
      RETVAL


int
AL_PLAYMODE_FORWARD()
   CODE:
      RETVAL = PLAYMODE_FORWARD;
   OUTPUT:
      RETVAL


int
AL_PLAYMODE_LOOP()
   CODE:
      RETVAL = PLAYMODE_LOOP;
   OUTPUT:
      RETVAL


int
AL_PLAYMODE_PLAY()
   CODE:
      RETVAL = PLAYMODE_PLAY;
   OUTPUT:
      RETVAL


int
AL_SWITCH_AMNESIA()
   CODE:
      RETVAL = SWITCH_AMNESIA;
   OUTPUT:
      RETVAL


int
AL_SWITCH_BACKAMNESIA()
   CODE:
      RETVAL = SWITCH_BACKAMNESIA;
   OUTPUT:
      RETVAL


int
AL_SWITCH_BACKGROUND()
   CODE:
      RETVAL = SWITCH_BACKGROUND;
   OUTPUT:
      RETVAL


int
AL_SWITCH_IN()
   CODE:
      RETVAL = SWITCH_IN;
   OUTPUT:
      RETVAL


int
AL_SWITCH_NONE()
   CODE:
      RETVAL = SWITCH_NONE;
   OUTPUT:
      RETVAL


int
AL_SWITCH_OUT()
   CODE:
      RETVAL = SWITCH_OUT;
   OUTPUT:
      RETVAL


int
AL_SWITCH_PAUSE()
   CODE:
      RETVAL = SWITCH_PAUSE;
   OUTPUT:
      RETVAL


int
AL_SYSTEM_AUTODETECT()
   CODE:
      RETVAL = SYSTEM_AUTODETECT;
   OUTPUT:
      RETVAL


int
AL_SYSTEM_NONE()
   CODE:
      RETVAL = SYSTEM_NONE;
   OUTPUT:
      RETVAL


void
al_acquire_bitmap(bmp)
   BITMAP *bmp
   CODE:
      acquire_bitmap(bmp);


void
al_adjust_sample(spl, vol, pan, freq, loop)
    SAMPLE *spl
   int vol
   int pan
   int freq
   int loop
   CODE:
      adjust_sample(spl, vol, pan, freq, loop);


void
al_allegro_exit()
   CODE:
      allegro_exit();


int
al_allocate_voice(spl)
    SAMPLE *spl
   CODE:
      RETVAL = allocate_voice(spl);
   OUTPUT:
      RETVAL


int
al_bitmap_color_depth(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = bitmap_color_depth(bmp);
   OUTPUT:
      RETVAL


int
al_bitmap_mask_color(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = bitmap_mask_color(bmp);
   OUTPUT:
      RETVAL


void
al_blit(source, dest, source_x, source_y, dest_x, dest_y, width, height)
   BITMAP *source
   BITMAP *dest
   int source_x
   int source_y
   int dest_x
   int dest_y
   int width
   int height
   CODE:
      blit(source, dest, source_x, source_y, dest_x, dest_y, width, height);


int
al_calibrate_joystick(n)
   int n
   CODE:
      RETVAL = calibrate_joystick(n);
   OUTPUT:
      RETVAL


const char *
al_calibrate_joystick_name(n)
   int n
   CODE:
      RETVAL = calibrate_joystick_name(n);
   OUTPUT:
      RETVAL


void
al_clear_bitmap(bitmap)
   BITMAP *bitmap
   CODE:
      clear_bitmap(bitmap);


void
al_clear_keybuf()
   CODE:
      clear_keybuf();


void
al_clear_to_color(bitmap, color)
   BITMAP *bitmap
   int color
   CODE:
      clear_to_color(bitmap, color);


BITMAP *
al_create_bitmap(width, height)
   int width
   int height
   CODE:
      RETVAL = create_bitmap(width, height);
   OUTPUT:
      RETVAL


BITMAP *
al_create_bitmap_ex(color_depth, width, height)
   int color_depth
   int width
   int height
   CODE:
      RETVAL = create_bitmap_ex(color_depth, width, height);
   OUTPUT:
      RETVAL


SAMPLE *
al_create_sample(bits, stereo, freq, len)
   int bits
   int stereo
   int freq
   int len
   CODE:
      RETVAL = create_sample(bits, stereo, freq, len);
   OUTPUT:
      RETVAL


BITMAP *
al_create_sub_bitmap(parent, x, y, width, height)
   BITMAP *parent
   int x
   int y
   int width
   int height
   CODE:
      RETVAL = create_sub_bitmap(parent, x, y, width, height);
   OUTPUT:
      RETVAL


BITMAP *
al_create_system_bitmap(width, height)
   int width
   int height
   CODE:
      RETVAL = create_system_bitmap(width, height);
   OUTPUT:
      RETVAL


BITMAP *
al_create_video_bitmap(width, height)
   int width
   int height
   CODE:
      RETVAL = create_video_bitmap(width, height);
   OUTPUT:
      RETVAL


void
al_deallocate_voice(voice)
   int voice
   CODE:
      deallocate_voice(voice);


int
al_desktop_color_depth()
   CODE:
      RETVAL = desktop_color_depth();
   OUTPUT:
      RETVAL


void
al_destroy_bitmap(bitmap)
   BITMAP *bitmap
   CODE:
      destroy_bitmap(bitmap);


void
al_destroy_font(f)
   FONT *f
   CODE:
      destroy_font(f);


void
al_destroy_midi(midi)
   MIDI *midi
   CODE:
      destroy_midi(midi);


void
al_destroy_rle_sprite(sprite)
   RLE_SPRITE *sprite
   CODE:
      destroy_rle_sprite(sprite);


void
al_destroy_sample(spl)
   SAMPLE *spl
   CODE:
      destroy_sample(spl);


void
al_draw_gouraud_sprite(bmp, sprite, x, y, c1, c2, c3, c4)
   BITMAP *bmp
   BITMAP *sprite
   int x
   int y
   int c1
   int c2
   int c3
   int c4
   CODE:
      draw_gouraud_sprite(bmp, sprite, x, y, c1, c2, c3, c4);


void
al_draw_lit_rle_sprite(bmp, sprite, x, y, color)
   BITMAP *bmp
    RLE_SPRITE *sprite
   int x
   int y
   int color
   CODE:
      draw_lit_rle_sprite(bmp, sprite, x, y, color);


void
al_draw_lit_sprite(bmp, sprite, x, y, color)
   BITMAP *bmp
   BITMAP *sprite
   int x
   int y
   int color
   CODE:
      draw_lit_sprite(bmp, sprite, x, y, color);


void
al_draw_rle_sprite(bmp, sprite, x, y)
   BITMAP *bmp
    RLE_SPRITE *sprite
   int x
   int y
   CODE:
      draw_rle_sprite(bmp, sprite, x, y);


void
al_draw_sprite(bmp, sprite, x, y)
   BITMAP *bmp
   BITMAP *sprite
   int x
   int y
   CODE:
      draw_sprite(bmp, sprite, x, y);


void
al_draw_trans_rle_sprite(bmp, sprite, x, y)
   BITMAP *bmp
    RLE_SPRITE *sprite
   int x
   int y
   CODE:
      draw_trans_rle_sprite(bmp, sprite, x, y);


void
al_draw_trans_sprite(bmp, sprite, x, y)
   BITMAP *bmp
   BITMAP *sprite
   int x
   int y
   CODE:
      draw_trans_sprite(bmp, sprite, x, y);


void
al_drawing_mode(mode, pattern, x_anchor, y_anchor)
   int mode
   BITMAP *pattern
   int x_anchor
   int y_anchor
   CODE:
      drawing_mode(mode, pattern, x_anchor, y_anchor);


void
al_ellipse(bmp, x, y, rx, ry, color)
   BITMAP *bmp
   int x
   int y
   int rx
   int ry
   int color
   CODE:
      ellipse(bmp, x, y, rx, ry, color);


void
al_ellipsefill(bmp, x, y, rx, ry, color)
   BITMAP *bmp
   int x
   int y
   int rx
   int ry
   int color
   CODE:
      ellipsefill(bmp, x, y, rx, ry, color);


void
al_fixup_datafile(data)
   DATAFILE *data
   CODE:
      fixup_datafile(data);


void
al_floodfill(bmp, x, y, color)
   BITMAP *bmp
   int x
   int y
   int color
   CODE:
      floodfill(bmp, x, y, color);


int
al_get_display_switch_mode()
   CODE:
      RETVAL = get_display_switch_mode();
   OUTPUT:
      RETVAL


void
al_get_palette(p)
   RGB * p
   CODE:
      get_palette(p);


int
al_get_refresh_rate()
   CODE:
      RETVAL = get_refresh_rate();
   OUTPUT:
      RETVAL


RLE_SPRITE *
al_get_rle_sprite(bitmap)
   BITMAP *bitmap
   CODE:
      RETVAL = get_rle_sprite(bitmap);
   OUTPUT:
      RETVAL


int
al_geta(c)
   int c
   CODE:
      RETVAL = geta(c);
   OUTPUT:
      RETVAL


int
al_geta_depth(color_depth, c)
   int color_depth
   int c
   CODE:
      RETVAL = geta_depth(color_depth, c);
   OUTPUT:
      RETVAL


int
al_getb(c)
   int c
   CODE:
      RETVAL = getb(c);
   OUTPUT:
      RETVAL


int
al_getb_depth(color_depth, c)
   int color_depth
   int c
   CODE:
      RETVAL = getb_depth(color_depth, c);
   OUTPUT:
      RETVAL


int
al_getg(c)
   int c
   CODE:
      RETVAL = getg(c);
   OUTPUT:
      RETVAL


int
al_getg_depth(color_depth, c)
   int color_depth
   int c
   CODE:
      RETVAL = getg_depth(color_depth, c);
   OUTPUT:
      RETVAL


int
al_getpixel(bmp, x, y)
   BITMAP *bmp
   int x
   int y
   CODE:
      RETVAL = getpixel(bmp, x, y);
   OUTPUT:
      RETVAL


int
al_getr(c)
   int c
   CODE:
      RETVAL = getr(c);
   OUTPUT:
      RETVAL


int
al_getr_depth(color_depth, c)
   int color_depth
   int c
   CODE:
      RETVAL = getr_depth(color_depth, c);
   OUTPUT:
      RETVAL


void
al_hline(bmp, x1, y, x2, color)
   BITMAP *bmp
   int x1
   int y
   int x2
   int color
   CODE:
      hline(bmp, x1, y, x2, color);


int
al_install_joystick(type)
   int type
   CODE:
      RETVAL = install_joystick(type);
   OUTPUT:
      RETVAL


int
al_install_keyboard()
   CODE:
      RETVAL = install_keyboard();
   OUTPUT:
      RETVAL


int
al_install_mouse()
   CODE:
      RETVAL = install_mouse();
   OUTPUT:
      RETVAL


int
al_install_sound(digi, midi, cfg_path)
   int digi
   int midi
   const char *cfg_path
   CODE:
      RETVAL = install_sound(digi, midi, cfg_path);
   OUTPUT:
      RETVAL


int
al_install_timer()
   CODE:
      RETVAL = install_timer();
   OUTPUT:
      RETVAL


int
al_is_memory_bitmap(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = is_memory_bitmap(bmp);
   OUTPUT:
      RETVAL


int
al_is_same_bitmap(bmp1, bmp2)
   BITMAP *bmp1
   BITMAP *bmp2
   CODE:
      RETVAL = is_same_bitmap(bmp1, bmp2);
   OUTPUT:
      RETVAL


int
al_is_screen_bitmap(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = is_screen_bitmap(bmp);
   OUTPUT:
      RETVAL


int
al_is_sub_bitmap(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = is_sub_bitmap(bmp);
   OUTPUT:
      RETVAL


int
al_is_system_bitmap(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = is_system_bitmap(bmp);
   OUTPUT:
      RETVAL


int
al_is_video_bitmap(bmp)
   BITMAP *bmp
   CODE:
      RETVAL = is_video_bitmap(bmp);
   OUTPUT:
      RETVAL


int
al_keypressed()
   CODE:
      RETVAL = keypressed();
   OUTPUT:
      RETVAL


void
al_line(bmp, x1, y1, x2, y2, color)
   BITMAP *bmp
   int x1
   int y1
   int x2
   int y2
   int color
   CODE:
      line(bmp, x1, y1, x2, y2, color);


BITMAP *
al_load_bitmap(filename, pal)
   const char *filename
   RGB *pal
   CODE:
      RETVAL = load_bitmap(filename, pal);
   OUTPUT:
      RETVAL


DATAFILE *
al_load_datafile(filename)
   const char *filename
   CODE:
      RETVAL = load_datafile(filename);
   OUTPUT:
      RETVAL


DATAFILE *
al_load_datafile_object(filename, objectname)
   const char *filename
   const char *objectname
   CODE:
      RETVAL = load_datafile_object(filename, objectname);
   OUTPUT:
      RETVAL


MIDI *
al_load_midi(filename)
   const char *filename
   CODE:
      RETVAL = load_midi(filename);
   OUTPUT:
      RETVAL


SAMPLE *
al_load_sample(filename)
   const char *filename
   CODE:
      RETVAL = load_sample(filename);
   OUTPUT:
      RETVAL


int
al_makeacol(r, g, b, a)
   int r
   int g
   int b
   int a
   CODE:
      RETVAL = makeacol(r, g, b, a);
   OUTPUT:
      RETVAL


int
al_makeacol_depth(color_depth, r, g, b, a)
   int color_depth
   int r
   int g
   int b
   int a
   CODE:
      RETVAL = makeacol_depth(color_depth, r, g, b, a);
   OUTPUT:
      RETVAL


int
al_makecol(r, g, b)
   int r
   int g
   int b
   CODE:
      RETVAL = makecol(r, g, b);
   OUTPUT:
      RETVAL


int
al_makecol_depth(color_depth, r, g, b)
   int color_depth
   int r
   int g
   int b
   CODE:
      RETVAL = makecol_depth(color_depth, r, g, b);
   OUTPUT:
      RETVAL


void
al_masked_blit(source, dest, source_x, source_y, dest_x, dest_y, width, height)
   BITMAP *source
   BITMAP *dest
   int source_x
   int source_y
   int dest_x
   int dest_y
   int width
   int height
   CODE:
      masked_blit(source, dest, source_x, source_y, dest_x, dest_y, width, height);


void
al_masked_stretch_blit(s, d, s_x, s_y, s_w, s_h, d_x, d_y, d_w, d_h)
   BITMAP *s
   BITMAP *d
   int s_x
   int s_y
   int s_w
   int s_h
   int d_x
   int d_y
   int d_w
   int d_h
   CODE:
      masked_stretch_blit(s, d, s_x, s_y, s_w, s_h, d_x, d_y, d_w, d_h);


void
al_midi_pause()
   CODE:
      midi_pause();


void
al_midi_resume()
   CODE:
      midi_resume();


int
al_midi_seek(target)
   int target
   CODE:
      RETVAL = midi_seek(target);
   OUTPUT:
      RETVAL


int
al_mouse_needs_poll()
   CODE:
      RETVAL = mouse_needs_poll();
   OUTPUT:
      RETVAL


void
al_packfile_password(password)
   const char *password
   CODE:
      packfile_password(password);


int
al_play_looped_midi(midi, loop_start, loop_end)
   MIDI *midi
   int loop_start
   int loop_end
   CODE:
      RETVAL = play_looped_midi(midi, loop_start, loop_end);
   OUTPUT:
      RETVAL


int
al_play_midi(midi, loop)
   MIDI *midi
   int loop
   CODE:
      RETVAL = play_midi(midi, loop);
   OUTPUT:
      RETVAL


int
al_play_sample(spl, vol, pan, freq, loop)
    SAMPLE *spl
   int vol
   int pan
   int freq
   int loop
   CODE:
      RETVAL = play_sample(spl, vol, pan, freq, loop);
   OUTPUT:
      RETVAL


int
al_poll_joystick()
   CODE:
      RETVAL = poll_joystick();
   OUTPUT:
      RETVAL


int
al_poll_keyboard()
   CODE:
      RETVAL = poll_keyboard();
   OUTPUT:
      RETVAL


int
al_poll_mouse()
   CODE:
      RETVAL = poll_mouse();
   OUTPUT:
      RETVAL


void
al_position_mouse(x, y)
   int x
   int y
   CODE:
      position_mouse(x, y);


void
al_position_mouse_z(z)
   int z
   CODE:
      position_mouse_z(z);


void
al_putpixel(bmp, x, y, color)
   BITMAP *bmp
   int x
   int y
   int color
   CODE:
      putpixel(bmp, x, y, color);


void
al_reallocate_voice(voice, spl)
   int voice
    SAMPLE *spl
   CODE:
      reallocate_voice(voice, spl);


void
al_rect(bmp, x1, y1, x2, y2, color)
   BITMAP *bmp
   int x1
   int y1
   int x2
   int y2
   int color
   CODE:
      rect(bmp, x1, y1, x2, y2, color);


void
al_rectfill(bmp, x1, y1, x2, y2, color)
   BITMAP *bmp
   int x1
   int y1
   int x2
   int y2
   int color
   CODE:
      rectfill(bmp, x1, y1, x2, y2, color);


void
al_release_bitmap(bmp)
   BITMAP *bmp
   CODE:
      release_bitmap(bmp);


void
al_release_voice(voice)
   int voice
   CODE:
      release_voice(voice);


void
al_remove_keyboard()
   CODE:
      remove_keyboard();


void
al_remove_mouse()
   CODE:
      remove_mouse();


void
al_remove_sound()
   CODE:
      remove_sound();


void
al_remove_timer()
   CODE:
      remove_timer();


void
al_request_refresh_rate(rate)
   int rate
   CODE:
      request_refresh_rate(rate);


void
al_reserve_voices(digi_voices, midi_voices)
   int digi_voices
   int midi_voices
   CODE:
      reserve_voices(digi_voices, midi_voices);


int
al_save_bitmap(filename, bmp, pal)
   const char *filename
   BITMAP *bmp
    RGB *pal
   CODE:
      RETVAL = save_bitmap(filename, bmp, pal);
   OUTPUT:
      RETVAL


void
al_scare_mouse()
   CODE:
      scare_mouse();


void
al_scare_mouse_area(x, y, w, h)
   int x
   int y
   int w
   int h
   CODE:
      scare_mouse_area(x, y, w, h);


int
al_scroll_screen(x, y)
   int x
   int y
   CODE:
      RETVAL = scroll_screen(x, y);
   OUTPUT:
      RETVAL


void
al_select_palette(p)
    RGB * p
   CODE:
      select_palette(p);


void
al_set_alpha_blender()
   CODE:
      set_alpha_blender();


void
al_set_clip(bitmap, x1, y1, x2, y2)
   BITMAP *bitmap
   int x1
   int y1
   int x2
   int y2
   CODE:
      set_clip(bitmap, x1, y1, x2, y2);


void
al_set_color_conversion(mode)
   int mode
   CODE:
      set_color_conversion(mode);


void
al_set_color_depth(depth)
   int depth
   CODE:
      set_color_depth(depth);


int
al_set_display_switch_mode(mode)
   int mode
   CODE:
      RETVAL = set_display_switch_mode(mode);
   OUTPUT:
      RETVAL


int
al_set_gfx_mode(card, w, h, v_w, v_h)
   int card
   int w
   int h
   int v_w
   int v_h
   CODE:
      RETVAL = set_gfx_mode(card, w, h, v_w, v_h);
   OUTPUT:
      RETVAL


void
al_set_keyboard_rate(delay, repeat)
   int delay
   int repeat
   CODE:
      set_keyboard_rate(delay, repeat);


void
al_set_leds(leds)
   int leds
   CODE:
      set_leds(leds);


void
al_set_mouse_range(x1, y1, x2, y2)
   int x1
   int y1
   int x2
   int y2
   CODE:
      set_mouse_range(x1, y1, x2, y2);


void
al_set_mouse_speed(xspeed, yspeed)
   int xspeed
   int yspeed
   CODE:
      set_mouse_speed(xspeed, yspeed);


void
al_set_mouse_sprite(sprite)
   BITMAP *sprite
   CODE:
      set_mouse_sprite(sprite);


void
al_set_mouse_sprite_focus(x, y)
   int x
   int y
   CODE:
      set_mouse_sprite_focus(x, y);


void
al_set_palette(p)
    RGB * p
   CODE:
      set_palette(p);


void
al_set_trans_blender(r, g, b, a)
   int r
   int g
   int b
   int a
   CODE:
      set_trans_blender(r, g, b, a);


void
al_set_volume(digi_volume, midi_volume)
   int digi_volume
   int midi_volume
   CODE:
      set_volume(digi_volume, midi_volume);


void
al_set_volume_per_voice(scale)
   int scale
   CODE:
      set_volume_per_voice(scale);


void
al_set_window_title(name)
   const char *name
   CODE:
      set_window_title(name);


void
al_show_mouse(bmp)
   BITMAP *bmp
   CODE:
      show_mouse(bmp);


int
al_show_video_bitmap(bitmap)
   BITMAP *bitmap
   CODE:
      RETVAL = show_video_bitmap(bitmap);
   OUTPUT:
      RETVAL


void
al_stop_midi()
   CODE:
      stop_midi();


void
al_stop_sample(spl)
    SAMPLE *spl
   CODE:
      stop_sample(spl);


void
al_stretch_blit(s, d, s_x, s_y, s_w, s_h, d_x, d_y, d_w, d_h)
   BITMAP *s
   BITMAP *d
   int s_x
   int s_y
   int s_w
   int s_h
   int d_x
   int d_y
   int d_w
   int d_h
   CODE:
      stretch_blit(s, d, s_x, s_y, s_w, s_h, d_x, d_y, d_w, d_h);


int
al_text_height(f)
    FONT *f
   CODE:
      RETVAL = text_height(f);
   OUTPUT:
      RETVAL


int
al_text_length(f, str)
    FONT *f
   const char *str
   CODE:
      RETVAL = text_length(f, str);
   OUTPUT:
      RETVAL


int
al_text_mode(mode)
   int mode
   CODE:
      RETVAL = text_mode(mode);
   OUTPUT:
      RETVAL


void
al_textout(bmp, f, str, x, y, color)
   BITMAP *bmp
    FONT *f
   const char *str
   int x
   int y
   int color
   CODE:
      textout(bmp, f, str, x, y, color);


void
al_textout_centre(bmp, f, str, x, y, color)
   BITMAP *bmp
    FONT *f
   const char *str
   int x
   int y
   int color
   CODE:
      textout_centre(bmp, f, str, x, y, color);


void
al_textout_justify(bmp, f, str, x1, x2, y, diff, color)
   BITMAP *bmp
    FONT *f
   const char *str
   int x1
   int x2
   int y
   int diff
   int color
   CODE:
      textout_justify(bmp, f, str, x1, x2, y, diff, color);


void
al_textout_right(bmp, f, str, x, y, color)
   BITMAP *bmp
    FONT *f
   const char *str
   int x
   int y
   int color
   CODE:
      textout_right(bmp, f, str, x, y, color);


void
al_triangle(bmp, x1, y1, x2, y2, x3, y3, color)
   BITMAP *bmp
   int x1
   int y1
   int x2
   int y2
   int x3
   int y3
   int color
   CODE:
      triangle(bmp, x1, y1, x2, y2, x3, y3, color);


void
al_unload_datafile(dat)
   DATAFILE *dat
   CODE:
      unload_datafile(dat);


void
al_unload_datafile_object(dat)
   DATAFILE *dat
   CODE:
      unload_datafile_object(dat);


void
al_unscare_mouse()
   CODE:
      unscare_mouse();


void
al_unselect_palette()
   CODE:
      unselect_palette();


void
al_vline(bmp, x, y1, y2, color)
   BITMAP *bmp
   int x
   int y1
   int y2
   int color
   CODE:
      vline(bmp, x, y1, y2, color);


SAMPLE *
al_voice_check(voice)
   int voice
   CODE:
      RETVAL = voice_check(voice);
   OUTPUT:
      RETVAL


int
al_voice_get_frequency(voice)
   int voice
   CODE:
      RETVAL = voice_get_frequency(voice);
   OUTPUT:
      RETVAL


int
al_voice_get_pan(voice)
   int voice
   CODE:
      RETVAL = voice_get_pan(voice);
   OUTPUT:
      RETVAL


int
al_voice_get_position(voice)
   int voice
   CODE:
      RETVAL = voice_get_position(voice);
   OUTPUT:
      RETVAL


int
al_voice_get_volume(voice)
   int voice
   CODE:
      RETVAL = voice_get_volume(voice);
   OUTPUT:
      RETVAL


void
al_voice_set_frequency(voice, frequency)
   int voice
   int frequency
   CODE:
      voice_set_frequency(voice, frequency);


void
al_voice_set_playmode(voice, playmode)
   int voice
   int playmode
   CODE:
      voice_set_playmode(voice, playmode);


void
al_voice_set_position(voice, position)
   int voice
   int position
   CODE:
      voice_set_position(voice, position);


void
al_voice_set_priority(voice, priority)
   int voice
   int priority
   CODE:
      voice_set_priority(voice, priority);


void
al_voice_set_volume(voice, volume)
   int voice
   int volume
   CODE:
      voice_set_volume(voice, volume);


void
al_voice_start(voice)
   int voice
   CODE:
      voice_start(voice);


void
al_voice_stop(voice)
   int voice
   CODE:
      voice_stop(voice);


void
al_vsync()
   CODE:
      vsync();


# Generated automatically by gen-auto-xsh-id
#
# Source files:
#   /usr/include/allegro/platform/aintbeos.h
#   /usr/include/allegro/platform/aintdos.h
#   /usr/include/allegro/platform/aintlnx.h
#   /usr/include/allegro/platform/aintmac.h
#   /usr/include/allegro/platform/aintqnx.h
#   /usr/include/allegro/platform/aintunix.h
#   /usr/include/allegro/platform/aintwin.h
#   /usr/include/allegro/platform/al386gcc.h
#   /usr/include/allegro/platform/al386vc.h
#   /usr/include/allegro/platform/al386wat.h
#   /usr/include/allegro/platform/albcc32.h
#   /usr/include/allegro/platform/albecfg.h
#   /usr/include/allegro/platform/albeos.h
#   /usr/include/allegro/platform/aldjgpp.h
#   /usr/include/allegro/platform/aldos.h
#   /usr/include/allegro/platform/almac.h
#   /usr/include/allegro/platform/almaccfg.h
#   /usr/include/allegro/platform/almngw32.h
#   /usr/include/allegro/platform/almsvc.h
#   /usr/include/allegro/platform/alplatf.h
#   /usr/include/allegro/platform/alqnx.h
#   /usr/include/allegro/platform/alqnxcfg.h
#   /usr/include/allegro/platform/alucfg.h
#   /usr/include/allegro/platform/alunix.h
#   /usr/include/allegro/platform/alunixac.h
#   /usr/include/allegro/platform/alwatcom.h
#   /usr/include/allegro/platform/alwin.h
#   /usr/include/allegro/platform/macdef.h
#

int
AL_SYSTEM_BEOS()
   CODE:
      RETVAL = AL_ID('B','S','Y','S');
   OUTPUT:
      RETVAL


int
AL_GFX_BEOS()
   CODE:
      RETVAL = AL_ID('B','F','S',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_BEOS_FULLSCREEN()
   CODE:
      RETVAL = AL_ID('B','F','S',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_BEOS_FULLSCREEN_SAFE()
   CODE:
      RETVAL = AL_ID('B','F','S','S');
   OUTPUT:
      RETVAL


int
AL_GFX_BEOS_WINDOWED()
   CODE:
      RETVAL = AL_ID('B','W','N',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_BEOS_WINDOWED_SAFE()
   CODE:
      RETVAL = AL_ID('B','W','N','S');
   OUTPUT:
      RETVAL


int
AL_DIGI_BEOS()
   CODE:
      RETVAL = AL_ID('B','D','I','G');
   OUTPUT:
      RETVAL


int
AL_MIDI_BEOS()
   CODE:
      RETVAL = AL_ID('B','M','I','D');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_DOS()
   CODE:
      RETVAL = AL_ID('D','O','S',' ');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_STANDARD()
   CODE:
      RETVAL = AL_ID('S','T','D',' ');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_2PADS()
   CODE:
      RETVAL = AL_ID('2','P','A','D');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_4BUTTON()
   CODE:
      RETVAL = AL_ID('4','B','U','T');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_6BUTTON()
   CODE:
      RETVAL = AL_ID('6','B','U','T');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_8BUTTON()
   CODE:
      RETVAL = AL_ID('8','B','U','T');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_FSPRO()
   CODE:
      RETVAL = AL_ID('F','P','R','O');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_WINGEX()
   CODE:
      RETVAL = AL_ID('W','I','N','G');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_SIDEWINDER()
   CODE:
      RETVAL = AL_ID('S','W',' ',' ');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_SIDEWINDER_AG()
   CODE:
      RETVAL = AL_ID('S','W','A','G');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_GAMEPAD_PRO()
   CODE:
      RETVAL = AL_ID('G','P','R','O');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_GRIP()
   CODE:
      RETVAL = AL_ID('G','R','I','P');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_GRIP4()
   CODE:
      RETVAL = AL_ID('G','R','I','4');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_SNESPAD_LPT1()
   CODE:
      RETVAL = AL_ID('S','N','E','1');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_SNESPAD_LPT2()
   CODE:
      RETVAL = AL_ID('S','N','E','2');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_SNESPAD_LPT3()
   CODE:
      RETVAL = AL_ID('S','N','E','3');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_PSXPAD_LPT1()
   CODE:
      RETVAL = AL_ID('P','S','X','1');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_PSXPAD_LPT2()
   CODE:
      RETVAL = AL_ID('P','S','X','2');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_PSXPAD_LPT3()
   CODE:
      RETVAL = AL_ID('P','S','X','3');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_N64PAD_LPT1()
   CODE:
      RETVAL = AL_ID('N','6','4','1');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_N64PAD_LPT2()
   CODE:
      RETVAL = AL_ID('N','6','4','2');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_N64PAD_LPT3()
   CODE:
      RETVAL = AL_ID('N','6','4','3');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_DB9_LPT1()
   CODE:
      RETVAL = AL_ID('D','B','9','1');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_DB9_LPT2()
   CODE:
      RETVAL = AL_ID('D','B','9','2');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_DB9_LPT3()
   CODE:
      RETVAL = AL_ID('D','B','9','3');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_TURBOGRAFX_LPT1()
   CODE:
      RETVAL = AL_ID('T','G','X','1');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_TURBOGRAFX_LPT2()
   CODE:
      RETVAL = AL_ID('T','G','X','2');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_TURBOGRAFX_LPT3()
   CODE:
      RETVAL = AL_ID('T','G','X','3');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_IFSEGA_ISA()
   CODE:
      RETVAL = AL_ID('S','E','G','I');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_IFSEGA_PCI()
   CODE:
      RETVAL = AL_ID('S','E','G','P');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_IFSEGA_PCI_FAST()
   CODE:
      RETVAL = AL_ID('S','G','P','F');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_WINGWARRIOR()
   CODE:
      RETVAL = AL_ID('W','W','A','R');
   OUTPUT:
      RETVAL


int
AL_GFX_VGA()
   CODE:
      RETVAL = AL_ID('V','G','A',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_MODEX()
   CODE:
      RETVAL = AL_ID('M','O','D','X');
   OUTPUT:
      RETVAL


int
AL_GFX_VESA1()
   CODE:
      RETVAL = AL_ID('V','B','E','1');
   OUTPUT:
      RETVAL


int
AL_GFX_VESA2B()
   CODE:
      RETVAL = AL_ID('V','B','2','B');
   OUTPUT:
      RETVAL


int
AL_GFX_VESA2L()
   CODE:
      RETVAL = AL_ID('V','B','2','L');
   OUTPUT:
      RETVAL


int
AL_GFX_VESA3()
   CODE:
      RETVAL = AL_ID('V','B','E','3');
   OUTPUT:
      RETVAL


int
AL_GFX_VBEAF()
   CODE:
      RETVAL = AL_ID('V','B','A','F');
   OUTPUT:
      RETVAL


int
AL_GFX_XTENDED()
   CODE:
      RETVAL = AL_ID('X','T','N','D');
   OUTPUT:
      RETVAL


int
AL_DIGI_SB10()
   CODE:
      RETVAL = AL_ID('S','B','1','0');
   OUTPUT:
      RETVAL


int
AL_DIGI_SB15()
   CODE:
      RETVAL = AL_ID('S','B','1','5');
   OUTPUT:
      RETVAL


int
AL_DIGI_SB20()
   CODE:
      RETVAL = AL_ID('S','B','2','0');
   OUTPUT:
      RETVAL


int
AL_DIGI_SBPRO()
   CODE:
      RETVAL = AL_ID('S','B','P',' ');
   OUTPUT:
      RETVAL


int
AL_DIGI_SB16()
   CODE:
      RETVAL = AL_ID('S','B','1','6');
   OUTPUT:
      RETVAL


int
AL_DIGI_AUDIODRIVE()
   CODE:
      RETVAL = AL_ID('E','S','S',' ');
   OUTPUT:
      RETVAL


int
AL_DIGI_SOUNDSCAPE()
   CODE:
      RETVAL = AL_ID('E','S','C',' ');
   OUTPUT:
      RETVAL


int
AL_DIGI_WINSOUNDSYS()
   CODE:
      RETVAL = AL_ID('W','S','S',' ');
   OUTPUT:
      RETVAL


int
AL_MIDI_OPL2()
   CODE:
      RETVAL = AL_ID('O','P','L','2');
   OUTPUT:
      RETVAL


int
AL_MIDI_2XOPL2()
   CODE:
      RETVAL = AL_ID('O','P','L','X');
   OUTPUT:
      RETVAL


int
AL_MIDI_OPL3()
   CODE:
      RETVAL = AL_ID('O','P','L','3');
   OUTPUT:
      RETVAL


int
AL_MIDI_SB_OUT()
   CODE:
      RETVAL = AL_ID('S','B',' ',' ');
   OUTPUT:
      RETVAL


int
AL_MIDI_MPU()
   CODE:
      RETVAL = AL_ID('M','P','U',' ');
   OUTPUT:
      RETVAL


int
AL_MIDI_AWE32()
   CODE:
      RETVAL = AL_ID('A','W','E',' ');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_MACOS()
   CODE:
      RETVAL = AL_ID('M','C','O','S');
   OUTPUT:
      RETVAL


int
AL_GFX_DRAWSPROCKET()
   CODE:
      RETVAL = AL_ID('D','S','P',' ');
   OUTPUT:
      RETVAL


int
AL_DIGI_MACOS()
   CODE:
      RETVAL = AL_ID('M','C','O','S');
   OUTPUT:
      RETVAL


int
AL_MIDI_QUICKTIME()
   CODE:
      RETVAL = AL_ID('Q','T',' ',' ');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_QNX()
   CODE:
      RETVAL = AL_ID('Q','S','Y','S');
   OUTPUT:
      RETVAL


int
AL_GFX_PHOTON()
   CODE:
      RETVAL = AL_ID('Q','P','H',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_PHOTON_DIRECT()
   CODE:
      RETVAL = AL_ID('Q','P','H','D');
   OUTPUT:
      RETVAL


int
AL_DIGI_ALSA()
   CODE:
      RETVAL = AL_ID('A','L','S','A');
   OUTPUT:
      RETVAL


int
AL_MIDI_ALSA()
   CODE:
      RETVAL = AL_ID('A','M','I','D');
   OUTPUT:
      RETVAL


int
AL_DIGI_OSS()
   CODE:
      RETVAL = AL_ID('O','S','S','D');
   OUTPUT:
      RETVAL


int
AL_MIDI_OSS()
   CODE:
      RETVAL = AL_ID('O','S','S','M');
   OUTPUT:
      RETVAL


int
AL_DIGI_ESD()
   CODE:
      RETVAL = AL_ID('E','S','D','D');
   OUTPUT:
      RETVAL


int
AL_DIGI_ARTS()
   CODE:
      RETVAL = AL_ID('A','R','T','S');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_XWINDOWS()
   CODE:
      RETVAL = AL_ID('X','W','I','N');
   OUTPUT:
      RETVAL


int
AL_GFX_XWINDOWS()
   CODE:
      RETVAL = AL_ID('X','W','I','N');
   OUTPUT:
      RETVAL


int
AL_GFX_XWINDOWS_FULLSCREEN()
   CODE:
      RETVAL = AL_ID('X','W','F','S');
   OUTPUT:
      RETVAL


int
AL_GFX_XDGA()
   CODE:
      RETVAL = AL_ID('X','D','G','A');
   OUTPUT:
      RETVAL


int
AL_GFX_XDGA_FULLSCREEN()
   CODE:
      RETVAL = AL_ID('X','D','F','S');
   OUTPUT:
      RETVAL


int
AL_GFX_XDGA2()
   CODE:
      RETVAL = AL_ID('D','G','A','2');
   OUTPUT:
      RETVAL


int
AL_GFX_XDGA2_SOFT()
   CODE:
      RETVAL = AL_ID('D','G','A','S');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_LINUX()
   CODE:
      RETVAL = AL_ID('L','N','X','C');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_LINUX_ANALOGUE()
   CODE:
      RETVAL = AL_ID('L','N','X','A');
   OUTPUT:
      RETVAL


int
AL_SYSTEM_DIRECTX()
   CODE:
      RETVAL = AL_ID('D','X',' ',' ');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX()
   CODE:
      RETVAL = AL_ID('D','X','A','C');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX_ACCEL()
   CODE:
      RETVAL = AL_ID('D','X','A','C');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX_SAFE()
   CODE:
      RETVAL = AL_ID('D','X','S','A');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX_SOFT()
   CODE:
      RETVAL = AL_ID('D','X','S','O');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX_WIN()
   CODE:
      RETVAL = AL_ID('D','X','W','N');
   OUTPUT:
      RETVAL


int
AL_GFX_DIRECTX_OVL()
   CODE:
      RETVAL = AL_ID('D','X','O','V');
   OUTPUT:
      RETVAL


int
AL_GFX_GDI()
   CODE:
      RETVAL = AL_ID('G','D','I','B');
   OUTPUT:
      RETVAL


int
AL_MIDI_WIN32MAPPER()
   CODE:
      RETVAL = AL_ID('W','3','2','M');
   OUTPUT:
      RETVAL


int
AL_JOY_TYPE_WIN32()
   CODE:
      RETVAL = AL_ID('W','3','2',' ');
   OUTPUT:
      RETVAL