static struct wl_display *wl_display;

static struct wl_display *dpy;

static struct wlr_renderer *renderer;

static struct wlr_renderer *drw;

	Keyboard *keyboard = calloc(1, sizeof(*keyboard));
	keyboard->device = device;

	Keyboard *kb = calloc(1, sizeof(*kb));
	kb->device = device;

	keyboard->modifiers.notify = keypressmod;
	wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);
	keyboard->key.notify = keypress;
	wl_signal_add(&device->keyboard->events.key, &keyboard->key);

	kb->modifiers.notify = keypressmod;
	wl_signal_add(&device->keyboard->events.modifiers, &kb->modifiers);
	kb->key.notify = keypress;
	wl_signal_add(&device->keyboard->events.key, &kb->key);

	wl_list_insert(&keyboards, &keyboard->link);

	wl_list_insert(&keyboards, &kb->link);

		if (!wlr_output_commit(wlr_output)) {

		if (!wlr_output_commit(wlr_output))

		}

	for (i = 0; i < LENGTH(monrules); i++) {

	for (i = 0; i < LENGTH(monrules); i++)

	}

	if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {

	if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)

	}

	if (prev_surface == surface) {
		/* Don't re-focus an already focused surface. */

	/* Don't re-focus an already focused surface. */
	if (prev_surface == surface)

	}

	if (!wl_list_empty(&keyboards)) {

	if (!wl_list_empty(&keyboards))

	}

	for (int i = 0; i < LENGTH(keys); i++) {

	for (int i = 0; i < LENGTH(keys); i++)

	}

	Keyboard *keyboard =
		wl_container_of(listener, keyboard, key);

	Keyboard *kb = wl_container_of(listener, kb, key);

			keyboard->device->keyboard->xkb_state, keycode, &syms);

			kb->device->keyboard->xkb_state, keycode, &syms);

	uint32_t mods = wlr_keyboard_get_modifiers(keyboard->device->keyboard);
	if (event->state == WLR_KEY_PRESSED) {
		/* On _press_, attempt to process a compositor keybinding. */
		for (int i = 0; i < nsyms; i++) {

	uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard);
	/* On _press_, attempt to process a compositor keybinding. */
	if (event->state == WLR_KEY_PRESSED)
		for (int i = 0; i < nsyms; i++)

		}
	}

		wlr_seat_set_keyboard(seat, keyboard->device);

		wlr_seat_set_keyboard(seat, kb->device);

	Keyboard *keyboard = wl_container_of(listener, keyboard, modifiers);

	Keyboard *kb = wl_container_of(listener, kb, modifiers);

	wlr_seat_set_keyboard(seat, keyboard->device);

	wlr_seat_set_keyboard(seat, kb->device);

		&keyboard->device->keyboard->modifiers);

		&kb->device->keyboard->modifiers);

	if (!c) {
		/* If there's no client under the cursor, set the cursor image to a
		 * default. This is what makes the cursor image appear when you move it
		 * around the screen, not over any clients. */

	/* If there's no client under the cursor, set the cursor image to a
	 * default. This is what makes the cursor image appear when you move it
	 * around the screen, not over any clients. */
	if (!c)

	}

	Client *c = xytoclient(cursor->x, cursor->y,
			&surface, &sx, &sy);
	if (!c) {

	Client *c = xytoclient(cursor->x, cursor->y, &surface, &sx, &sy);
	if (!c)

	}

	wl_display_terminate(wl_display);

	wl_display_terminate(dpy);

	if (texture == NULL) {

	if (!texture)

	}

	wlr_render_texture_with_matrix(renderer, texture, matrix, 1);

	wlr_render_texture_with_matrix(drw, texture, matrix, 1);

	if (!wlr_output_attach_render(m->wlr_output, NULL)) {

	if (!wlr_output_attach_render(m->wlr_output, NULL))

	}

	wlr_renderer_begin(renderer, m->wlr_output->width, m->wlr_output->height);
	wlr_renderer_clear(renderer, rootcolor);

	wlr_renderer_begin(drw, m->wlr_output->width, m->wlr_output->height);
	wlr_renderer_clear(drw, rootcolor);

	wlr_renderer_end(renderer);

	wlr_renderer_end(drw);

	Client *c = xytoclient(cursor->x, cursor->y,
			&surface, &sx, &sy);
	if (!c) {

	Client *c = xytoclient(cursor->x, cursor->y, &surface, &sx, &sy);
	if (!c)

	}

	const char *socket = wl_display_add_socket_auto(wl_display);

	const char *socket = wl_display_add_socket_auto(dpy);

		wl_display_destroy(wl_display);

		wl_display_destroy(dpy);

			wl_display_destroy(wl_display);

			wl_display_destroy(dpy);

			wl_display_destroy(wl_display);

			wl_display_destroy(dpy);

	wl_display_run(wl_display);

	wl_display_run(dpy);

	struct wlr_seat_client *focused_client =
		seat->pointer_state.focused_client;

	 * actually has pointer focus first. */
	if (focused_client == event->seat_client) {
		/* Once we've vetted the client, we can tell the cursor to use the
		 * provided surface as the cursor image. It will set the hardware cursor
		 * on the output that it's currently on and continue to do so as the
		 * cursor moves between outputs. */

	 * actually has pointer focus first. If so, we can tell the cursor to
	 * use the provided surface as the cursor image. It will set the
	 * hardware cursor on the output that it's currently on and continue to
	 * do so as the cursor moves between outputs. */
	if (event->seat_client == seat->pointer_state.focused_client)

	}

	backend = wlr_backend_autocreate(wl_display, NULL);

	backend = wlr_backend_autocreate(dpy, NULL);

	renderer = wlr_backend_get_renderer(backend);
	wlr_renderer_init_wl_display(renderer, wl_display);

	drw = wlr_backend_get_renderer(backend);
	wlr_renderer_init_wl_display(drw, dpy);

	wlr_compositor_create(wl_display, renderer);
	wlr_data_device_manager_create(wl_display);

	wlr_compositor_create(dpy, drw);
	wlr_data_device_manager_create(dpy);

	xdg_shell = wlr_xdg_shell_create(wl_display);

	xdg_shell = wlr_xdg_shell_create(dpy);

	seat = wlr_seat_create(wl_display, "seat0");

	seat = wlr_seat_create(dpy, "seat0");

		if (_surface != NULL) {

		if (_surface) {

	wl_display = wl_display_create();

	dpy = wl_display_create();

	wl_display_destroy_clients(wl_display);
	wl_display_destroy(wl_display);

	wl_display_destroy_clients(dpy);
	wl_display_destroy(dpy);