win = XCreateSimpleWindow(display, RootWindow(display, screen),
       0, 0, width, height, 3, BlackPixel(display, screen), WhitePixel(display, screen));

       priv->bits = FTK_ZALLOC(width * height * priv->pixelsize);
       priv->ximage = XCreateImage(display, priv->visual, priv->depth, ZPixmap,
           0, (char*)priv->bits, width, height,
           32, width * priv->pixelsize);

static int ftk_display_x11_width(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return priv->width;
}

static int ftk_display_x11_height(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return priv->height;
}

static Ret ftk_display_x11_update(FtkDisplay* thiz, FtkBitmap* bitmap, FtkRect* rect, int xoffset, int yoffset)
{
    Ret ret = RET_FAIL;
    DECL_PRIV(thiz, priv);
 
    if(bitmap != NULL)
    {
       int display_width  = priv->width;
       int display_height = priv->height;
       ret = priv->copy_to_data(bitmap, rect,
           priv->bits, xoffset, yoffset, display_width, display_height);
       XPutImage(priv->display, priv->win, priv->gc, priv->ximage,
           xoffset, yoffset, xoffset, yoffset, rect->width, rect->height);
    }
    else
    {
       XPutImage(priv->display, priv->win, priv->gc, priv->ximage, 0, 0, 0, 0, priv->width, priv->height);
       ret = RET_OK;
    }
 
    XFlush(priv->display);
    XSync(priv->display, 0);
 
    return ret;
}

static Ret ftk_display_x11_snap(FtkDisplay* thiz, FtkRect* r, FtkBitmap* bitmap)
{
    FtkRect rect = {0};
    DECL_PRIV(thiz, priv);
    int w = ftk_display_width(thiz);
    int h = ftk_display_height(thiz);
    int bw = ftk_bitmap_width(bitmap);
    int bh = ftk_bitmap_height(bitmap);
 
    rect.x = r->x;
    rect.y = r->y;
    rect.width = FTK_MIN(bw, r->width);
    rect.height = FTK_MIN(bh, r->height);
 
    return priv->copy_from_data(bitmap, priv->bits, w, h, &rect);
}

FtkDisplay* ftk_display_mem_create(FtkPixelFormat format,
    int width, int height, void* bits, FtkDestroy on_destroy, void* ctx)
{
    FtkDisplay* thiz = NULL;
 
    thiz = (FtkDisplay*)FTK_ZALLOC(sizeof(FtkDisplay) + sizeof(PrivInfo));
    if(thiz != NULL)
    {
       DECL_PRIV(thiz, priv);
       thiz->update   = ftk_display_mem_update;
       thiz->width    = ftk_display_mem_width;
       thiz->height   = ftk_display_mem_height;
       thiz->snap     = ftk_display_mem_snap;
       thiz->destroy  = ftk_display_mem_destroy;
 
       priv->bits = bits;
       priv->width = width;
       priv->height = height;
       priv->format = format;
       priv->on_destroy = on_destroy;
       priv->on_destroy_ctx = ctx;
 
       switch(format)
       {
           case FTK_PIXEL_RGB565:
           {
               priv->copy_to_data   = ftk_bitmap_copy_to_data_rgb565;
               priv->copy_from_data = ftk_bitmap_copy_from_data_rgb565;
               break;
           }
           case FTK_PIXEL_BGR24:
           {
               priv->copy_to_data   = ftk_bitmap_copy_to_data_bgr24;
               priv->copy_from_data = ftk_bitmap_copy_from_data_bgr24;
               break;
           }
           case FTK_PIXEL_BGRA32:
           {
               priv->copy_to_data   = ftk_bitmap_copy_to_data_bgra32;
               priv->copy_from_data = ftk_bitmap_copy_from_data_bgra32;
               break;
           }
           case FTK_PIXEL_RGBA32:
           {
               priv->copy_to_data   = ftk_bitmap_copy_to_data_rgba32;
               priv->copy_from_data = ftk_bitmap_copy_from_data_rgba32;
               break;
           }
           default:
           {
               assert(!"not supported framebuffer format.");
               break;
           }
       }
    }
 
    return thiz;
}

static int ftk_display_mem_width(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return priv->width;
}

static int ftk_display_mem_height(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return priv->height;
}

static Ret ftk_display_mem_update(FtkDisplay* thiz, FtkBitmap* bitmap, FtkRect* rect, int xoffset, int yoffset)
{
    DECL_PRIV(thiz, priv);
    int display_width  = priv->width;
    int display_height = priv->height;
    return_val_if_fail(priv != NULL, RET_FAIL);
 
    ftk_logd("%s: ox=%d oy=%d (%d %d %d %d)\n", __func__, xoffset, yoffset,
       rect->x, rect->y, rect->width, rect->height);
    return priv->copy_to_data(bitmap, rect,
       priv->bits, xoffset, yoffset, display_width, display_height);
}

static Ret ftk_display_mem_snap(FtkDisplay* thiz, FtkRect* r, FtkBitmap* bitmap)
{
    FtkRect rect = {0};
    DECL_PRIV(thiz, priv);
    int w = ftk_display_width(thiz);
    int h = ftk_display_height(thiz);
    int bw = ftk_bitmap_width(bitmap);
    int bh = ftk_bitmap_height(bitmap);
    return_val_if_fail(priv != NULL, RET_FAIL);
 
    rect.x = r->x;
    rect.y = r->y;
    rect.width = FTK_MIN(bw, r->width);
    rect.height = FTK_MIN(bh, r->height);
 
    return priv->copy_from_data(bitmap, priv->bits, w, h, &rect);
}

static int fb_open(struct FbInfo *fb, const char* fbfilename)
{
    fb->fd = open(fbfilename, O_RDWR);
    if (fb->fd < 0)
    {
       return -1;
    }
 
    if (ioctl(fb->fd, FBIOGET_FSCREENINFO, &fb->fi) < 0)
       goto fail;
    if (ioctl(fb->fd, FBIOGET_VSCREENINFO, &fb->vi) < 0)
       goto fail;
 
#ifdef FTK_FB_NOMMAP
    //uclinux doesn't support MAP_SHARED or MAP_PRIVATE with PROT_WRITE, so no mmap at all is simpler
    fb->bits = fb->fi.smem_start;
#else
    fb->bits = mmap(0, fb_size(fb), PROT_READ | PROT_WRITE, MAP_SHARED, fb->fd, 0);
#endif
}

   thiz = ftk_display_mem_create(format, fb->vi.xres, fb->vi.yres,
           fb->bits, fb_close, fb);

FtkDisplay* ftk_display_rotate_create(FtkDisplay* display, FtkRotate rotate)
{
    FtkDisplay* thiz = NULL;
    return_val_if_fail(display != NULL, NULL);
 
    thiz = FTK_ZALLOC(sizeof(FtkDisplay) + sizeof(PrivInfo));
 
    if(thiz != NULL)
    {
       DECL_PRIV(thiz, priv);
 
       priv->display = display;
       thiz->width   = ftk_display_rotate_width;
       thiz->height  = ftk_display_rotate_height;
       thiz->destroy = ftk_display_rotate_destroy;
 
       ftk_display_set_rotate(thiz, rotate);
    }
 
    return thiz;
}

static int ftk_display_rotate_width(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return (priv->rotate == FTK_ROTATE_0 || priv->rotate == FTK_ROTATE_180) ?
       ftk_display_width(priv->display) : ftk_display_height(priv->display);
}

static int ftk_display_rotate_height(FtkDisplay* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, 0);
 
    return (priv->rotate != FTK_ROTATE_0 && priv->rotate != FTK_ROTATE_180) ?
       ftk_display_width(priv->display) : ftk_display_height(priv->display);
}

static const FtkDisplayUpdate updates[FTK_ROTATE_NR] =
{
    ftk_display_rotate_update_0,
    ftk_display_rotate_update_90,
    ftk_display_rotate_update_180,
    ftk_display_rotate_update_270
};
 
static const FtkDisplaySnap snaps[FTK_ROTATE_NR] =
{
    ftk_display_rotate_snap_0,
    ftk_display_rotate_snap_90,
    ftk_display_rotate_snap_180,
    ftk_display_rotate_snap_270
};
 
Ret ftk_display_set_rotate(FtkDisplay* thiz, FtkRotate rotate)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL && priv->display != NULL, RET_FAIL);
    return_val_if_fail(thiz->destroy == ftk_display_rotate_destroy, RET_FAIL);
 
    if(priv->rotate == rotate && priv->bitmap != NULL)
    {
       return RET_OK;
    }
 
    priv->rotate = rotate;
    if(priv->bitmap != NULL)
    {
       ftk_bitmap_unref(priv->bitmap);
       priv->bitmap = NULL;
    }
 
    if(priv->rotate != FTK_ROTATE_0)
    {
       FtkColor bg = {0};
       memset(&bg, 0xff, sizeof(bg));
       priv->bitmap = ftk_bitmap_create(ftk_display_width(priv->display),        ftk_display_height(priv->display), bg);
    }
 
    thiz->snap = snaps[rotate];
    thiz->update = updates[rotate];
 
    return RET_OK;
}

static int ftk_source_input_get_fd(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
 
    return priv->fd;
}
 
static int ftk_source_input_check(FtkSource* thiz)
{
    return -1;
}

static unsigned short s_key_map[0x100] =
{
    [KEY_1]           =  FTK_KEY_1,
    [KEY_2]           =  FTK_KEY_2,
    [KEY_3]           =  FTK_KEY_3,
    [KEY_4]           =  FTK_KEY_4,
    [KEY_5]           =  FTK_KEY_5,
    [KEY_6]           =  FTK_KEY_6,
    [KEY_7]           =  FTK_KEY_7,
   ...
};

static int  ftk_source_dfb_get_fd(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
 
    return priv->fd;
}
 
static int  ftk_source_dfb_check(FtkSource* thiz)
{
    return -1;
}

static const int s_key_map[] =
{
    [DIKI_A-DIKI_UNKNOWN]              =  FTK_KEY_a,
    [DIKI_B-DIKI_UNKNOWN]              =  FTK_KEY_b,
    [DIKI_C-DIKI_UNKNOWN]              =  FTK_KEY_c,
    [DIKI_D-DIKI_UNKNOWN]              =  FTK_KEY_d,
    [DIKI_E-DIKI_UNKNOWN]              =  FTK_KEY_e,
    [DIKI_F-DIKI_UNKNOWN]              =  FTK_KEY_f,
    [DIKI_G-DIKI_UNKNOWN]              =  FTK_KEY_g,
    [DIKI_H-DIKI_UNKNOWN]              =  FTK_KEY_h,
   ...
};

static int ftk_source_tslib_get_fd(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL && priv->ts != NULL, -1);
 
    return ts_fd(priv->ts);
}
 
static int ftk_source_tslib_check(FtkSource* thiz)
{
    return -1;
}

static int ftk_source_primary_get_fd(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv != NULL, -1);
 
    return ftk_pipe_get_read_handle(priv->pipe);
}
 
static int ftk_source_primary_check(FtkSource* thiz)
{
    return -1;
}

static int ftk_source_timer_get_fd(FtkSource* thiz)
{
    return -1;
}

static int ftk_source_timer_check(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
    int t = priv->next_time - ftk_get_relative_time();
 
    t = t < 0 ? 0 : t;
 
    return t;
}

tatic Ret ftk_source_timer_dispatch(FtkSource* thiz)
{
    Ret ret = RET_FAIL;
    DECL_PRIV(thiz, priv);
    return_val_if_fail(priv->action != NULL, RET_REMOVE);
 
    if(thiz->disable > 0)
    {
       ftk_source_timer_calc_timer(priv);
       return RET_OK;
    }
 
    ret = priv->action(priv->user_data);
    ftk_source_timer_calc_timer(priv);
 
    return ret;
}

static int ftk_source_idle_get_fd(FtkSource* thiz)
{
    return -1;
}
 
static int ftk_source_idle_check(FtkSource* thiz)
{
    return 0;
}

static Ret ftk_source_idle_dispatch(FtkSource* thiz)
{
    DECL_PRIV(thiz, priv);
 
    return_val_if_fail(priv->action != NULL, RET_REMOVE);
 
    if(thiz->disable > 0)
    {
       return RET_OK;
    }
 
    return priv->action(priv->user_data);
}

int init_dirs(void)
{
    umask(0);
    mkdir("/dev", 0755);
    mkdir("/system", 0777);
    mkdir("/dev/block", 0755);
 
    return 0;
}

int init_dev_nodes(void)
{
    int ret = 0;
    ret = mknod("/dev/block/mtdblock0", 0755|S_IFBLK, makedev(31, 0));
    printf("mknod /dev/block/mtdblock0 ret = %d errno=%d\n", ret, errno);
 
    return 0;
}

int mount_filesystem(void)
{
    int ret = 0;
    ret = mount("/dev/block/mtdblock0", "/system", "yaffs2", 0, NULL);
    printf("mount /dev/block/mtdblock0 ret = %d errno=%d\n", ret, errno);
 
    return 0;
}

int startup_desktop(const char* name)
{
    struct stat st = {0};
    int ret = stat(name, &st);
 
    if(ret != 0)
    {
       return -1;
    }
 
    printf("starting the second init: %s.\n", name);
 
    if(fork() == 0)
    {
       ret = execl(name, name);
    }
 
    return ret;
}
 
int switch_root(void)
{
    int ret = chroot("/system");
    ret = startup_desktop("/opt/bin/desktop");
 
    return ret;
}

rm -rf ramdisk
mkdir ramdisk
 
cd init && make; cd - >/dev/null
 
echo "Generating ramdisk..."
 
cd ramdisk && find . | cpio -c -o > ../initrd; cd - >/dev/null
gzip initrd && mv initrd.gz ramdisk.img

if [ ! -d rootfs ]
then
    tar xf rootfs.tar.gz
fi

./mkyaffs2image rootfs system.img

echo "Copying files..."
for f in ramdisk.img system.img
do
    echo "  $f --> $ADNROID_SDK_IMAGES_DIR"
    mv -f $f $ADNROID_SDK_IMAGES_DIR
done

    while(GetMessage(&msg))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    ftk_run();

Ret ftk_main_loop_add_source(FtkMainLoop* thiz, FtkSource* source)
{
    FtkEvent event = {0};
    return_val_if_fail(thiz != NULL && source != NULL, RET_FAIL);
 
    event.type = FTK_EVT_ADD_SOURCE;
    event.u.extra = source;
 
    return ftk_source_queue_event(ftk_primary_source(), &event);
}
 
Ret ftk_main_loop_remove_source(FtkMainLoop* thiz, FtkSource* source)
{
    FtkEvent event = {0};
    return_val_if_fail(thiz != NULL && source != NULL, RET_FAIL);
 
    event.type = FTK_EVT_REMOVE_SOURCE;
    event.u.extra = source;
 
    return ftk_source_queue_event(ftk_primary_source(), &event);
}

static Ret ftk_source_primary_dispatch(FtkSource* thiz)
{
    ...
    switch(event.type)
    {
        case FTK_EVT_ADD_SOURCE:
        {
            ftk_sources_manager_add(ftk_default_sources_manager(), event.u.extra);
            break;
        }
        case FTK_EVT_REMOVE_SOURCE:
        {
            ftk_sources_manager_remove(ftk_default_sources_manager(), event.u.extra);
            break;
        }
    }
    ...
}

        for(i = 0; i < ftk_sources_manager_get_count(thiz->sources_manager); i++)
        {
            source = ftk_sources_manager_get(thiz->sources_manager, i);
            if((fd = ftk_source_get_fd(source)) >= 0)
            {
                FD_SET(fd, &thiz->fdset);
                if(mfd < fd) mfd = fd;
                n++;
            }
 
            source_wait_time = ftk_source_check(source);
            if(source_wait_time >= 0 && source_wait_time < wait_time)
            {
                wait_time = source_wait_time;
            }
        }

        tv.tv_sec = wait_time/1000;
        tv.tv_usec = (wait_time%1000) * 1000;
        ret = select(mfd + 1, &thiz->fdset, NULL, NULL, &tv);

            if( (ret > 0) && (fd = ftk_source_get_fd(source)) >= 0 && FD_ISSET(fd, &thiz->fdset))
            {
                if(ftk_source_dispatch(source) != RET_OK)
                {
                    /*as current is removed, the next will be move to current, so dont call i++*/
                    ftk_sources_manager_remove(thiz->sources_manager, source);
                    ftk_logd("%s:%d remove %p\n", __func__, __LINE__, source);
                }
                else
                {
                    i++;
                }
                continue;
            }
            //这里处理timer和idle。
            if((source_wait_time = ftk_source_check(source)) == 0)
            {
                if(ftk_source_dispatch(source) != RET_OK)
                {
                    /*as current is removed, the next will be move to current, so dont call i++*/
                    ftk_sources_manager_remove(thiz->sources_manager, source);
                    //ftk_logd("%s:%d remove %p\n", __func__, __LINE__, source);
                }
                else
                {
                    i++;
                }
                continue;
            }

int ftk_dialog_run(FtkWidget* thiz)
{
    DECL_PRIV1(thiz, priv);
    return_val_if_fail(thiz != NULL, RET_FAIL);
    return_val_if_fail(ftk_widget_type(thiz) == FTK_DIALOG, RET_FAIL);
 
    ftk_widget_show_all(thiz, 1);
    priv->main_loop = ftk_main_loop_create(ftk_default_sources_manager());
    ftk_main_loop_run(priv->main_loop);
    ftk_main_loop_destroy(priv->main_loop);
    priv->main_loop = NULL;
 
    return ftk_widget_id(ftk_window_get_focus(thiz));
}

Ret ftk_dialog_quit(FtkWidget* thiz)
{
    DECL_PRIV1(thiz, priv);
    return_val_if_fail(ftk_dialog_is_modal(thiz), RET_FAIL);
 
    ftk_main_loop_quit(priv->main_loop);
 
    return RET_OK;
}

#include <stdio.h>
#include <stdlib.h>
 
typedef struct _Book
{
    int isbn;
    char name[32];
    char author[32];
}Book;
 
int main(int argc, char* argv[])
{
    int a[100] = {0};
    Book b = {0};
 
    return 0;
}

    int a[100] = {0};
 80483a3:    8d 95 68 fe ff ff        lea    -0x198(%ebp),%edx
 80483a9:    b8 90 01 00 00           mov    $0x190,%eax
 80483ae:    89 44 24 08              mov    %eax,0x8(%esp)
 80483b2:    c7 44 24 04 00 00 00     movl   $0x0,0x4(%esp)
 80483b9:    00
 80483ba:    89 14 24                 mov    %edx,(%esp)
 80483bd:    e8 06 ff ff ff           call   80482c8 <memset@plt>
    Book b = {0};
 80483c2:    8d 95 18 fe ff ff        lea    -0x1e8(%ebp),%edx
 80483c8:    b8 44 00 00 00           mov    $0x44,%eax
 80483cd:    89 44 24 08              mov    %eax,0x8(%esp)
 80483d1:    c7 44 24 04 00 00 00     movl   $0x0,0x4(%esp)
 80483d8:    00
 80483d9:    89 14 24                 mov    %edx,(%esp)
 80483dc:    e8 e7 fe ff ff           call   80482c8 <memset@plt>

ftk_window.c
ftk_window.h

/*
* File: 文件名
* Author: 作者及邮件
* Brief: 说明
*
* Copyright (c) 2009 - 2010 版权
*
* Licensed under the Academic Free License version 2.1
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
 
/*
* History:
* ================================================================
* date who what
*
*/

# adb push out/target/product/littleton/system/xbin/sqlite3 /data

adb shell
# cd /data
# chmod 775 sqlite3

# ./sqlite3 /data/data/com.android.providers.settings/databases/settings.db

sqlite> .tables
android_metadata   bookmarks          secure           
bluetooth_devices  gservices          system

sqlite> select * from system;
1|volume_music|11
3|volume_system|5
5|volume_alarm|6
7|mode_ringer|2
8|vibrate_on|4
9|mode_ringer_streams_affected|38
10|mute_streams_affected|46
11|dim_screen|1
12|stay_on_while_plugged_in|0
13|screen_off_timeout|60000
14|airplane_mode_on|0
15|airplane_mode_radios|cell,bluetooth,wifi
16|auto_time|1
17|screen_brightness|102
18|window_animation_scale|1.0
19|transition_animation_scale|0.0
20|accelerometer_rotation|1
21|dtmf_tone|0
22|date_format|MM-dd-yyyy
23|notify_led_color|255
24|notify_incoming_call|1
25|notify_missed_call|1
26|notify_SMS_MMS|1
27|notify_email|1
28|notify_voice_mail|1
29|notify_remind|1
63|volume_voice|4
64|volume_voice_last_audible|4
73|lock_pattern_tactile_feedback_enabled|0
111|lock_pattern_visible_pattern|１
122|font_scale|1.0
127|next_alarm_formatted|
129|lock_pattern_autolock|１
130|lockscreen.patterneverchosen|1
131|volume_notification|5
132|volume_notification_last_audible|5
133|volume_ring|5
134|volume_ring_last_audible|5
135|lockscreen.lockedoutpermanently|1

sqlite> .schema system
CREATE TABLE system (_id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT UNIQUE ON CONFLICT REPLACE,value TEXT);
CREATE INDEX systemIndex1 ON system (name);

sqlite> update system set value='0' where name='lockscreen.lockedoutpermanently';
sqlite> update system set value='0' where name='lock_pattern_autolock';
sqlite> update system set value='0' where name='lock_pattern_visible_pattern';

sqlite> .quit

/data # reboot

cd external/privoxy-3.0.15-beta;
autoheader && autoconf && ./configure --disable-acl-files;
make

#
# Copyright :  Written by and Copyright (C) 2010 Li XianJing <xianjimli@hotmail.com>
#
LOCAL_PATH:= $(call my-dir)
 
include $(CLEAR_VARS)
 
LOCAL_C_CFLAGS=-DANDROID
LOCAL_C_INCLUDES += external/privoxy/pcre external/privoxy external/zlib
LOCAL_SRC_FILES:= actions.c cgi.c cgiedit.c cgisimple.c deanimate.c \
    encode.c errlog.c filters.c gateway.c jbsockets.c jcc.c list.c \
    loadcfg.c loaders.c miscutil.c parsers.c ssplit.c urlmatch.c  \
    pcrs.c pcre/get.c pcre/maketables.c pcre/study.c pcre/pcre.c \
    pcre/pcreposix.c
 
LOCAL_MODULE := privoxy
 
LOCAL_SHARED_LIBRARIES := libc
LOCAL_STATIC_LIBRARIES := libz
include $(BUILD_EXECUTABLE)

#if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV)
-->
#if !defined(HAVE_TIMEGM) && defined(HAVE_TZSET) && defined(HAVE_PUTENV) || defined(ANDROID)

mm

adb forward tcp:8118 tcp:8118