/* addrlookup.c generated by valac 0.12.0, the Vala compiler
 * generated from addrlookup.vala, do not modify */


#include <glib.h>
#include <glib-object.h>
#include <notmuch.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <gobject/gvaluecollector.h>


#define TYPE_ADDRESS_MATCHER (address_matcher_get_type ())
#define ADDRESS_MATCHER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADDRESS_MATCHER, AddressMatcher))
#define ADDRESS_MATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADDRESS_MATCHER, AddressMatcherClass))
#define IS_ADDRESS_MATCHER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADDRESS_MATCHER))
#define IS_ADDRESS_MATCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADDRESS_MATCHER))
#define ADDRESS_MATCHER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADDRESS_MATCHER, AddressMatcherClass))

typedef struct _AddressMatcher AddressMatcher;
typedef struct _AddressMatcherClass AddressMatcherClass;
typedef struct _AddressMatcherPrivate AddressMatcherPrivate;
#define _notmuch_database_close0(var) ((var == NULL) ? NULL : (var = (notmuch_database_close (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _g_key_file_free0(var) ((var == NULL) ? NULL : (var = (g_key_file_free (var), NULL)))

#define ADDRESS_MATCHER_TYPE_MAILADDRESS_FREQ (address_matcher_mailaddress_freq_get_type ())
typedef struct _AddressMatcherMailAddress_freq AddressMatcherMailAddress_freq;
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
#define _g_match_info_free0(var) ((var == NULL) ? NULL : (var = (g_match_info_free (var), NULL)))
#define _0(var) ((var == NULL) ? NULL : (var = ( (var), NULL)))
#define _address_matcher_mailaddress_freq_free0(var) ((var == NULL) ? NULL : (var = (address_matcher_mailaddress_freq_free (var), NULL)))
#define __g_list_free__address_matcher_mailaddress_freq_free0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__address_matcher_mailaddress_freq_free0_ (var), NULL)))
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
typedef struct _ParamSpecAddressMatcher ParamSpecAddressMatcher;
#define _address_matcher_unref0(var) ((var == NULL) ? NULL : (var = (address_matcher_unref (var), NULL)))

struct _AddressMatcher {
	GTypeInstance parent_instance;
	volatile int ref_count;
	AddressMatcherPrivate * priv;
};

struct _AddressMatcherClass {
	GTypeClass parent_class;
	void (*finalize) (AddressMatcher *self);
};

struct _AddressMatcherPrivate {
	notmuch_database_t* db;
	gchar* user_db_path;
	gchar* user_primary_email;
	gchar* user_addrbook_tag;
};

struct _AddressMatcherMailAddress_freq {
	gchar* address;
	guint* occurances;
	gint occurances_length1;
	gint _occurances_size_;
};

struct _ParamSpecAddressMatcher {
	GParamSpec parent_instance;
};


static gpointer address_matcher_parent_class = NULL;

gpointer address_matcher_ref (gpointer instance);
void address_matcher_unref (gpointer instance);
GParamSpec* param_spec_address_matcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void value_set_address_matcher (GValue* value, gpointer v_object);
void value_take_address_matcher (GValue* value, gpointer v_object);
gpointer value_get_address_matcher (const GValue* value);
GType address_matcher_get_type (void) G_GNUC_CONST;
#define ADDRESS_MATCHER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_ADDRESS_MATCHER, AddressMatcherPrivate))
enum  {
	ADDRESS_MATCHER_DUMMY_PROPERTY
};
AddressMatcher* address_matcher_new (void);
AddressMatcher* address_matcher_construct (GType object_type);
static GType address_matcher_mailaddress_freq_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
static AddressMatcherMailAddress_freq* address_matcher_mailaddress_freq_dup (const AddressMatcherMailAddress_freq* self);
static void address_matcher_mailaddress_freq_free (AddressMatcherMailAddress_freq* self);
static void address_matcher_mailaddress_freq_copy (const AddressMatcherMailAddress_freq* self, AddressMatcherMailAddress_freq* dest);
static void address_matcher_mailaddress_freq_destroy (AddressMatcherMailAddress_freq* self);
static gint address_matcher_sort_by_freq (AddressMatcherMailAddress_freq* mail1, AddressMatcherMailAddress_freq* mail2);
gchar* address_matcher_frequent_fullname (AddressMatcher* self, GHashTable* frequencies);
GHashTable* address_matcher_addresses_by_frequency (AddressMatcher* self, notmuch_messages_t* msgs, const gchar* name, guint pass, GHashTable** addr2realname);
gchar** address_matcher_search_address_passes (AddressMatcher* self, notmuch_query_t** queries, int queries_length1, const gchar* name, int* result_length1);
static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value);
static void _address_matcher_mailaddress_freq_free0_ (gpointer var);
static void _g_list_free__address_matcher_mailaddress_freq_free0_ (GList* self);
void address_matcher_run (AddressMatcher* self, const gchar* name);
static void _vala_array_add2 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);
static void _vala_array_add3 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);
static void _vala_array_add4 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value);
static guint* _vala_array_dup1 (guint* self, int length);
static void address_matcher_finalize (AddressMatcher* obj);
gint _vala_main (gchar** args, int args_length1);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);


AddressMatcher* address_matcher_construct (GType object_type) {
	AddressMatcher* self = NULL;
	GKeyFile* _tmp0_ = NULL;
	GKeyFile* config;
	const gchar* _tmp1_ = NULL;
	gchar* _tmp2_;
	gchar* home;
	gchar* _tmp5_;
	gchar* _tmp6_;
	gchar* _tmp7_ = NULL;
	gchar* _tmp8_;
	gchar* _tmp9_ = NULL;
	gchar* _tmp10_;
	gchar* _tmp11_ = NULL;
	gchar* _tmp12_;
	GError * _inner_error_ = NULL;
	self = (AddressMatcher*) g_type_create_instance (object_type);
	_tmp0_ = g_key_file_new ();
	config = _tmp0_;
	_tmp1_ = g_getenv ("NOTMUCH_CONFIG");
	_tmp2_ = g_strdup (_tmp1_);
	home = _tmp2_;
	if (home == NULL) {
		const gchar* _tmp3_ = NULL;
		gchar* _tmp4_;
		_tmp3_ = g_get_home_dir ();
		_tmp4_ = g_strdup (_tmp3_);
		_g_free0 (home);
		home = _tmp4_;
	}
	_tmp5_ = g_strconcat (home, "/.notmuch-config", NULL);
	_tmp6_ = _tmp5_;
	g_key_file_load_from_file (config, _tmp6_, G_KEY_FILE_NONE, &_inner_error_);
	_g_free0 (_tmp6_);
	if (_inner_error_ != NULL) {
		goto __catch0_g_error;
	}
	_tmp7_ = g_key_file_get_string (config, "database", "path", &_inner_error_);
	_tmp8_ = _tmp7_;
	if (_inner_error_ != NULL) {
		goto __catch0_g_error;
	}
	_g_free0 (self->priv->user_db_path);
	self->priv->user_db_path = _tmp8_;
	goto __finally0;
	__catch0_g_error:
	{
		GError * ex;
		ex = _inner_error_;
		_inner_error_ = NULL;
		_g_error_free0 (ex);
	}
	__finally0:
	if (_inner_error_ != NULL) {
		_g_free0 (home);
		_g_key_file_free0 (config);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp9_ = g_key_file_get_string (config, "user", "primary_email", &_inner_error_);
	_tmp10_ = _tmp9_;
	if (_inner_error_ != NULL) {
		goto __catch1_g_error;
	}
	_g_free0 (self->priv->user_primary_email);
	self->priv->user_primary_email = _tmp10_;
	goto __finally1;
	__catch1_g_error:
	{
		GError * ex;
		ex = _inner_error_;
		_inner_error_ = NULL;
		_g_error_free0 (ex);
	}
	__finally1:
	if (_inner_error_ != NULL) {
		_g_free0 (home);
		_g_key_file_free0 (config);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp11_ = g_key_file_get_string (config, "user", "addrbook_tag", &_inner_error_);
	_tmp12_ = _tmp11_;
	if (_inner_error_ != NULL) {
		goto __catch2_g_error;
	}
	_g_free0 (self->priv->user_addrbook_tag);
	self->priv->user_addrbook_tag = _tmp12_;
	goto __finally2;
	__catch2_g_error:
	{
		GError * ex;
		gchar* _tmp13_;
		ex = _inner_error_;
		_inner_error_ = NULL;
		_tmp13_ = g_strdup ("addressbook");
		_g_free0 (self->priv->user_addrbook_tag);
		self->priv->user_addrbook_tag = _tmp13_;
		_g_error_free0 (ex);
	}
	__finally2:
	if (_inner_error_ != NULL) {
		_g_free0 (home);
		_g_key_file_free0 (config);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_g_free0 (home);
	_g_key_file_free0 (config);
	return self;
}


AddressMatcher* address_matcher_new (void) {
	return address_matcher_construct (TYPE_ADDRESS_MATCHER);
}


static gint address_matcher_sort_by_freq (AddressMatcherMailAddress_freq* mail1, AddressMatcherMailAddress_freq* mail2) {
	gint result = 0;
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp3_ = FALSE;
	if ((*mail1).occurances[0] == (*mail2).occurances[0]) {
		_tmp1_ = (*mail1).occurances[1] == (*mail2).occurances[1];
	} else {
		_tmp1_ = FALSE;
	}
	if (_tmp1_) {
		_tmp0_ = (*mail1).occurances[2] == (*mail2).occurances[2];
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		result = 0;
		return result;
	}
	if ((*mail1).occurances[0] > (*mail2).occurances[0]) {
		_tmp3_ = TRUE;
	} else {
		gboolean _tmp4_ = FALSE;
		if ((*mail1).occurances[0] == (*mail2).occurances[0]) {
			_tmp4_ = (*mail1).occurances[1] > (*mail2).occurances[1];
		} else {
			_tmp4_ = FALSE;
		}
		_tmp3_ = _tmp4_;
	}
	if (_tmp3_) {
		_tmp2_ = TRUE;
	} else {
		gboolean _tmp5_ = FALSE;
		gboolean _tmp6_ = FALSE;
		if ((*mail1).occurances[0] == (*mail2).occurances[0]) {
			_tmp6_ = (*mail1).occurances[1] == (*mail2).occurances[1];
		} else {
			_tmp6_ = FALSE;
		}
		if (_tmp6_) {
			_tmp5_ = (*mail1).occurances[2] > (*mail2).occurances[2];
		} else {
			_tmp5_ = FALSE;
		}
		_tmp2_ = _tmp5_;
	}
	if (_tmp2_) {
		result = -1;
		return result;
	}
	result = 1;
	return result;
}


static gboolean string_contains (const gchar* self, const gchar* needle) {
	gboolean result = FALSE;
	gchar* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (needle != NULL, FALSE);
	_tmp0_ = strstr ((gchar*) self, (gchar*) needle);
	result = _tmp0_ != NULL;
	return result;
}


gchar* address_matcher_frequent_fullname (AddressMatcher* self, GHashTable* frequencies) {
	gchar* result = NULL;
	guint maxfreq;
	gchar* fullname;
	GList* _tmp0_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (frequencies != NULL, NULL);
	maxfreq = (guint) 0;
	fullname = NULL;
	_tmp0_ = g_hash_table_get_keys (frequencies);
	{
		GList* mail_collection;
		GList* mail_it;
		mail_collection = _tmp0_;
		for (mail_it = mail_collection; mail_it != NULL; mail_it = mail_it->next) {
			const gchar* mail;
			mail = (const gchar*) mail_it->data;
			{
				gconstpointer _tmp1_ = NULL;
				guint freq;
				gboolean _tmp2_ = FALSE;
				gboolean _tmp3_ = FALSE;
				_tmp1_ = g_hash_table_lookup (frequencies, mail);
				freq = GPOINTER_TO_UINT (_tmp1_);
				if (freq > maxfreq) {
					gboolean _tmp4_;
					_tmp4_ = string_contains (mail, " ");
					_tmp3_ = _tmp4_;
				} else {
					_tmp3_ = FALSE;
				}
				if (_tmp3_) {
					_tmp2_ = TRUE;
				} else {
					guint _tmp5_;
					_tmp5_ = g_hash_table_size (frequencies);
					_tmp2_ = _tmp5_ == 1;
				}
				if (_tmp2_) {
					gchar* _tmp6_;
					maxfreq = freq;
					_tmp6_ = g_strdup (mail);
					_g_free0 (fullname);
					fullname = _tmp6_;
				}
			}
		}
		_g_list_free0 (mail_collection);
	}
	result = fullname;
	return result;
}


static gpointer _g_hash_table_ref0 (gpointer self) {
	return self ? g_hash_table_ref (self) : NULL;
}


GHashTable* address_matcher_addresses_by_frequency (AddressMatcher* self, notmuch_messages_t* msgs, const gchar* name, guint pass, GHashTable** addr2realname) {
	GHashTable* result = NULL;
	GHashTable* _tmp0_ = NULL;
	GHashTable* ht;
	GRegex* re;
	GRegex* _tmp1_ = NULL;
	GRegex* _tmp2_;
	gchar* _tmp3_;
	gchar** _tmp4_ = NULL;
	gchar** headers;
	gint headers_length1;
	gint _headers_size_;
	GError * _inner_error_ = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (msgs != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	g_return_val_if_fail (addr2realname != NULL, NULL);
	_tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
	ht = _tmp0_;
	re = NULL;
	_tmp1_ = g_regex_new ("\\s*((\\\"(\\\\.|[^\\\\\"])*\\\"|[^,])*" "<?(?P<mail>\\b\\w+([-+.]\\w+)*\\@\\w+[-\\.\\w]*\\.([-\\.\\w]+)*\\w\\b)" \
">?)", 0, 0, &_inner_error_);
	_tmp2_ = _tmp1_;
	if (_inner_error_ != NULL) {
		if (_inner_error_->domain == G_REGEX_ERROR) {
			goto __catch3_g_regex_error;
		}
		_g_regex_unref0 (re);
		_g_hash_table_unref0 (ht);
		g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_g_regex_unref0 (re);
	re = _tmp2_;
	goto __finally3;
	__catch3_g_regex_error:
	{
		GError * ex;
		ex = _inner_error_;
		_inner_error_ = NULL;
		_g_error_free0 (ex);
	}
	__finally3:
	if (_inner_error_ != NULL) {
		_g_regex_unref0 (re);
		_g_hash_table_unref0 (ht);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp3_ = g_strdup ("from");
	_tmp4_ = g_new0 (gchar*, 1 + 1);
	_tmp4_[0] = _tmp3_;
	headers = _tmp4_;
	headers_length1 = 1;
	_headers_size_ = 1;
	if (pass == 1) {
		gchar* _tmp5_;
		gchar* _tmp6_;
		gchar* _tmp7_;
		gchar** _tmp8_ = NULL;
		_tmp5_ = g_strdup ("to");
		_tmp6_ = g_strdup ("cc");
		_tmp7_ = g_strdup ("bcc");
		_tmp8_ = g_new0 (gchar*, 3 + 1);
		_tmp8_[0] = _tmp5_;
		_tmp8_[1] = _tmp6_;
		_tmp8_[2] = _tmp7_;
		headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);
		headers = _tmp8_;
		headers_length1 = 3;
		_headers_size_ = 3;
	}
	while (TRUE) {
		gboolean _tmp9_;
		GMatchInfo* matches = NULL;
		notmuch_message_t* _tmp10_ = NULL;
		notmuch_message_t* msg;
		_tmp9_ = notmuch_messages_valid (msgs);
		if (!_tmp9_) {
			break;
		}
		_tmp10_ = notmuch_messages_get (msgs);
		msg = _tmp10_;
		{
			gchar** header_collection;
			int header_collection_length1;
			int header_it;
			header_collection = headers;
			header_collection_length1 = headers_length1;
			for (header_it = 0; header_it < headers_length1; header_it = header_it + 1) {
				gchar* _tmp11_;
				gchar* header;
				_tmp11_ = g_strdup (header_collection[header_it]);
				header = _tmp11_;
				{
					const gchar* _tmp12_ = NULL;
					gchar* _tmp13_;
					gchar* froms;
					GMatchInfo* _tmp14_ = NULL;
					gboolean _tmp15_;
					gboolean found;
					_tmp12_ = notmuch_message_get_header (msg, header);
					_tmp13_ = g_strdup ((const gchar*) _tmp12_);
					froms = _tmp13_;
					_tmp15_ = g_regex_match (re, froms, 0, &_tmp14_);
					_g_match_info_free0 (matches);
					matches = _tmp14_;
					found = _tmp15_;
					while (TRUE) {
						gchar* _tmp16_ = NULL;
						gchar* from;
						gchar* _tmp17_ = NULL;
						gchar* addr;
						gchar* _tmp18_ = NULL;
						gboolean _tmp19_;
						gboolean _tmp20_;
						gchar* _tmp21_;
						gchar* _tmp22_;
						gboolean _tmp23_;
						gboolean _tmp24_;
						gboolean is_match;
						gconstpointer _tmp25_ = NULL;
						guint occurs;
						gchar* _tmp26_;
						gconstpointer _tmp27_ = NULL;
						GHashTable* _tmp28_;
						GHashTable* realname_freq;
						gconstpointer _tmp32_ = NULL;
						gchar* _tmp33_;
						if (!found) {
							break;
						}
						_tmp16_ = g_match_info_fetch (matches, 1);
						from = _tmp16_;
						_tmp17_ = g_match_info_fetch_named (matches, "mail");
						addr = _tmp17_;
						_tmp18_ = g_utf8_strdown (addr, (gssize) (-1));
						_g_free0 (addr);
						addr = _tmp18_;
						_tmp19_ = g_match_info_next (matches, &_inner_error_);
						_tmp20_ = _tmp19_;
						if (_inner_error_ != NULL) {
							if (_inner_error_->domain == G_REGEX_ERROR) {
								goto __catch4_g_regex_error;
							}
							_g_free0 (addr);
							_g_free0 (from);
							_g_free0 (froms);
							_g_free0 (header);
							_0 (msg);
							_g_match_info_free0 (matches);
							headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);
							_g_regex_unref0 (re);
							_g_hash_table_unref0 (ht);
							g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
							g_clear_error (&_inner_error_);
							return NULL;
						}
						found = _tmp20_;
						goto __finally4;
						__catch4_g_regex_error:
						{
							GError * ex;
							ex = _inner_error_;
							_inner_error_ = NULL;
							_g_error_free0 (ex);
						}
						__finally4:
						if (_inner_error_ != NULL) {
							_g_free0 (addr);
							_g_free0 (from);
							_g_free0 (froms);
							_g_free0 (header);
							_0 (msg);
							_g_match_info_free0 (matches);
							headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);
							_g_regex_unref0 (re);
							_g_hash_table_unref0 (ht);
							g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
							g_clear_error (&_inner_error_);
							return NULL;
						}
						_tmp21_ = g_strconcat ("\\b", name, NULL);
						_tmp22_ = _tmp21_;
						_tmp23_ = g_regex_match_simple (_tmp22_, from, G_REGEX_CASELESS, 0);
						_tmp24_ = _tmp23_;
						_g_free0 (_tmp22_);
						is_match = _tmp24_;
						if (!is_match) {
							_g_free0 (addr);
							_g_free0 (from);
							continue;
						}
						_tmp25_ = g_hash_table_lookup (ht, addr);
						occurs = GPOINTER_TO_UINT (_tmp25_) + 1;
						_tmp26_ = g_strdup (addr);
						g_hash_table_replace (ht, _tmp26_, GUINT_TO_POINTER (occurs));
						_tmp27_ = g_hash_table_lookup (*addr2realname, addr);
						_tmp28_ = _g_hash_table_ref0 ((GHashTable*) _tmp27_);
						realname_freq = _tmp28_;
						if (realname_freq == NULL) {
							GHashTable* _tmp29_ = NULL;
							gchar* _tmp30_;
							GHashTable* _tmp31_;
							_tmp29_ = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
							_g_hash_table_unref0 (realname_freq);
							realname_freq = _tmp29_;
							_tmp30_ = g_strdup (addr);
							_tmp31_ = _g_hash_table_ref0 (realname_freq);
							g_hash_table_insert (*addr2realname, _tmp30_, _tmp31_);
						}
						_tmp32_ = g_hash_table_lookup (realname_freq, from);
						occurs = GPOINTER_TO_UINT (_tmp32_) + 1;
						_tmp33_ = g_strdup (from);
						g_hash_table_replace (realname_freq, _tmp33_, GUINT_TO_POINTER (occurs));
						_g_hash_table_unref0 (realname_freq);
						_g_free0 (addr);
						_g_free0 (from);
					}
					_g_free0 (froms);
					_g_free0 (header);
				}
			}
		}
		notmuch_message_destroy (msg);
		notmuch_messages_move_to_next (msgs);
		_0 (msg);
		_g_match_info_free0 (matches);
	}
	result = ht;
	headers = (_vala_array_free (headers, headers_length1, (GDestroyNotify) g_free), NULL);
	_g_regex_unref0 (re);
	return result;
}


static gpointer _address_matcher_mailaddress_freq_dup0 (gpointer self) {
	return self ? address_matcher_mailaddress_freq_dup (self) : NULL;
}


static void _vala_array_add1 (gchar*** array, int* length, int* size, gchar* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (gchar*, *array, (*size) + 1);
	}
	(*array)[(*length)++] = value;
	(*array)[*length] = NULL;
}


static void _address_matcher_mailaddress_freq_free0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (address_matcher_mailaddress_freq_free (var), NULL));
}


static void _g_list_free__address_matcher_mailaddress_freq_free0_ (GList* self) {
	g_list_foreach (self, (GFunc) _address_matcher_mailaddress_freq_free0_, NULL);
	g_list_free (self);
}


gchar** address_matcher_search_address_passes (AddressMatcher* self, notmuch_query_t** queries, int queries_length1, const gchar* name, int* result_length1) {
	gchar** result = NULL;
	gchar** return_value;
	gint return_value_length1;
	gint _return_value_size_;
	GHashTable* _tmp0_ = NULL;
	GHashTable* addrfreq;
	GHashTable* _tmp1_ = NULL;
	GHashTable* addr2realname;
	guint pass;
	GList* _tmp16_ = NULL;
	GList* addrs;
	gchar** _tmp21_;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (name != NULL, NULL);
	return_value = NULL;
	return_value_length1 = 0;
	_return_value_size_ = 0;
	_tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
	addrfreq = _tmp0_;
	_tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
	addr2realname = _tmp1_;
	pass = (guint) 0;
	{
		notmuch_query_t** q_collection;
		int q_collection_length1;
		int q_it;
		q_collection = queries;
		q_collection_length1 = queries_length1;
		for (q_it = 0; q_it < queries_length1; q_it = q_it + 1) {
			notmuch_query_t* q;
			q = q_collection[q_it];
			{
				notmuch_messages_t* _tmp2_ = NULL;
				notmuch_messages_t* msgs;
				GHashTable* _tmp3_ = NULL;
				GHashTable* ht;
				GList* _tmp4_ = NULL;
				_tmp2_ = notmuch_query_search_messages (q);
				msgs = _tmp2_;
				_tmp3_ = address_matcher_addresses_by_frequency (self, msgs, name, pass, &addr2realname);
				ht = _tmp3_;
				_tmp4_ = g_hash_table_get_keys (ht);
				{
					GList* addr_collection;
					GList* addr_it;
					addr_collection = _tmp4_;
					for (addr_it = addr_collection; addr_it != NULL; addr_it = addr_it->next) {
						const gchar* addr;
						addr = (const gchar*) addr_it->data;
						{
							gconstpointer _tmp5_ = NULL;
							AddressMatcherMailAddress_freq* _tmp6_;
							AddressMatcherMailAddress_freq* freq;
							gconstpointer _tmp13_ = NULL;
							gchar* _tmp14_;
							AddressMatcherMailAddress_freq* _tmp15_;
							_tmp5_ = g_hash_table_lookup (addrfreq, addr);
							_tmp6_ = _address_matcher_mailaddress_freq_dup0 ((AddressMatcherMailAddress_freq*) _tmp5_);
							freq = _tmp6_;
							if (freq == NULL) {
								gchar* _tmp7_;
								guint* _tmp8_ = NULL;
								AddressMatcherMailAddress_freq _tmp9_ = {0};
								AddressMatcherMailAddress_freq _tmp10_ = {0};
								AddressMatcherMailAddress_freq _tmp11_;
								AddressMatcherMailAddress_freq* _tmp12_;
								_tmp7_ = g_strdup (addr);
								_tmp8_ = g_new0 (guint, 3);
								_tmp8_[0] = (guint) 0;
								_tmp8_[1] = (guint) 0;
								_tmp8_[2] = (guint) 0;
								memset (&_tmp9_, 0, sizeof (AddressMatcherMailAddress_freq));
								_tmp9_.address = _tmp7_;
								_tmp9_.occurances = _tmp8_;
								_tmp9_.occurances_length1 = 3;
								_tmp10_ = _tmp9_;
								_tmp11_ = _tmp10_;
								_tmp12_ = _address_matcher_mailaddress_freq_dup0 (&_tmp11_);
								_address_matcher_mailaddress_freq_free0 (freq);
								freq = _tmp12_;
								address_matcher_mailaddress_freq_destroy (&_tmp11_);
							}
							_tmp13_ = g_hash_table_lookup (ht, addr);
							(*freq).occurances[pass] = GPOINTER_TO_UINT (_tmp13_);
							_tmp14_ = g_strdup (addr);
							_tmp15_ = _address_matcher_mailaddress_freq_dup0 (freq);
							g_hash_table_replace (addrfreq, _tmp14_, _tmp15_);
							_address_matcher_mailaddress_freq_free0 (freq);
						}
					}
					_g_list_free0 (addr_collection);
				}
				notmuch_messages_destroy (msgs);
				pass = pass + ((guint) 1);
				_g_hash_table_unref0 (ht);
				_0 (msgs);
			}
		}
	}
	_tmp16_ = g_hash_table_get_values (addrfreq);
	addrs = _tmp16_;
	addrs = g_list_sort (addrs, (GCompareFunc) address_matcher_sort_by_freq);
	{
		GList* addr_collection;
		GList* addr_it;
		addr_collection = addrs;
		for (addr_it = addr_collection; addr_it != NULL; addr_it = addr_it->next) {
			AddressMatcherMailAddress_freq* _tmp17_;
			AddressMatcherMailAddress_freq* addr;
			_tmp17_ = _address_matcher_mailaddress_freq_dup0 ((AddressMatcherMailAddress_freq*) addr_it->data);
			addr = _tmp17_;
			{
				gconstpointer _tmp18_ = NULL;
				GHashTable* _tmp19_;
				GHashTable* freqs;
				gchar* _tmp20_ = NULL;
				_tmp18_ = g_hash_table_lookup (addr2realname, (*addr).address);
				_tmp19_ = _g_hash_table_ref0 ((GHashTable*) _tmp18_);
				freqs = _tmp19_;
				_tmp20_ = address_matcher_frequent_fullname (self, freqs);
				_vala_array_add1 (&return_value, &return_value_length1, &_return_value_size_, _tmp20_);
				_g_hash_table_unref0 (freqs);
				_address_matcher_mailaddress_freq_free0 (addr);
			}
		}
	}
	_tmp21_ = return_value;
	*result_length1 = return_value_length1;
	result = _tmp21_;
	__g_list_free__address_matcher_mailaddress_freq_free0_0 (addrs);
	_g_hash_table_unref0 (addr2realname);
	_g_hash_table_unref0 (addrfreq);
	return result;
}


static void _vala_array_add2 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (notmuch_query_t*, *array, *size);
	}
	(*array)[(*length)++] = value;
}


static void _vala_array_add3 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (notmuch_query_t*, *array, *size);
	}
	(*array)[(*length)++] = value;
}


static void _vala_array_add4 (notmuch_query_t*** array, int* length, int* size, notmuch_query_t* value) {
	if ((*length) == (*size)) {
		*size = (*size) ? (2 * (*size)) : 4;
		*array = g_renew (notmuch_query_t*, *array, *size);
	}
	(*array)[(*length)++] = value;
}


void address_matcher_run (AddressMatcher* self, const gchar* name) {
	notmuch_query_t** _tmp0_ = NULL;
	notmuch_query_t** queries;
	gint queries_length1;
	gint _queries_size_;
	notmuch_database_t* _tmp1_ = NULL;
	gchar* _tmp2_;
	gchar* _tmp3_;
	GString* _tmp4_ = NULL;
	GString* _tmp5_;
	GString* querystr;
	notmuch_query_t* _tmp10_ = NULL;
	GString* _tmp11_ = NULL;
	notmuch_query_t* _tmp18_ = NULL;
	guint _tmp19_;
	guint _tmp20_;
	gint _tmp27_;
	gchar** _tmp28_ = NULL;
	gchar** _result_;
	gint _result__length1;
	gint __result__size_;
	notmuch_status_t status;

	g_return_if_fail (self != NULL);
	_tmp0_ = g_new0 (notmuch_query_t*, 0);
	queries = _tmp0_;
	queries_length1 = 0;
	_queries_size_ = 0;
	status = notmuch_database_open (self->priv->user_db_path, NOTMUCH_DATABASE_MODE_READ_ONLY, &_tmp1_);
	_notmuch_database_close0 (self->priv->db);
	self->priv->db = _tmp1_;
	_tmp2_ = g_strconcat ("tag:", self->priv->user_addrbook_tag, NULL);
	_tmp3_ = _tmp2_;
	_tmp4_ = g_string_new (_tmp3_);
	_tmp5_ = _tmp4_;
	_g_free0 (_tmp3_);
	querystr = _tmp5_;
	if (name != NULL) {
		gchar* _tmp6_;
		gchar* _tmp7_;
		gchar* _tmp8_;
		gchar* _tmp9_;
		_tmp6_ = g_strconcat (" and from:", name, NULL);
		_tmp7_ = _tmp6_;
		_tmp8_ = g_strconcat (_tmp7_, "*", NULL);
		_tmp9_ = _tmp8_;
		g_string_append (querystr, _tmp9_);
		_g_free0 (_tmp9_);
		_g_free0 (_tmp7_);
	} else {
		name = "";
	}
	_tmp10_ = notmuch_query_create (self->priv->db, querystr->str);
	_vala_array_add2 (&queries, &queries_length1, &_queries_size_, _tmp10_);
	_tmp11_ = g_string_new ("");
	_g_string_free0 (querystr);
	querystr = _tmp11_;
	if (name != NULL) {
		gchar* _tmp12_;
		gchar* _tmp13_;
		gchar* _tmp14_;
		gchar* _tmp15_;
		_tmp12_ = g_strconcat ("to:", name, NULL);
		_tmp13_ = _tmp12_;
		_tmp14_ = g_strconcat (_tmp13_, "*", NULL);
		_tmp15_ = _tmp14_;
		g_string_append (querystr, _tmp15_);
		_g_free0 (_tmp15_);
		_g_free0 (_tmp13_);
	}
	if (self->priv->user_primary_email != NULL) {
		gchar* _tmp16_;
		gchar* _tmp17_;
		_tmp16_ = g_strconcat (" from:", self->priv->user_primary_email, NULL);
		_tmp17_ = _tmp16_;
		g_string_append (querystr, _tmp17_);
		_g_free0 (_tmp17_);
	}
	_tmp18_ = notmuch_query_create (self->priv->db, querystr->str);
	_vala_array_add3 (&queries, &queries_length1, &_queries_size_, _tmp18_);
	_tmp19_ = notmuch_query_count_messages (queries[0]);
	_tmp20_ = notmuch_query_count_messages (queries[1]);
	if ((_tmp19_ + _tmp20_) < 10) {
		GString* _tmp21_ = NULL;
		notmuch_query_t* _tmp26_ = NULL;
		_tmp21_ = g_string_new ("");
		_g_string_free0 (querystr);
		querystr = _tmp21_;
		if (name != NULL) {
			gchar* _tmp22_;
			gchar* _tmp23_;
			gchar* _tmp24_;
			gchar* _tmp25_;
			_tmp22_ = g_strconcat ("from:", name, NULL);
			_tmp23_ = _tmp22_;
			_tmp24_ = g_strconcat (_tmp23_, "*", NULL);
			_tmp25_ = _tmp24_;
			g_string_append (querystr, _tmp25_);
			_g_free0 (_tmp25_);
			_g_free0 (_tmp23_);
		}
		_tmp26_ = notmuch_query_create (self->priv->db, querystr->str);
		_vala_array_add4 (&queries, &queries_length1, &_queries_size_, _tmp26_);
	}
	_tmp28_ = address_matcher_search_address_passes (self, queries, queries_length1, name, &_tmp27_);
	_result_ = _tmp28_;
	_result__length1 = _tmp27_;
	__result__size_ = _tmp27_;
	{
		gchar** addr_collection;
		int addr_collection_length1;
		int addr_it;
		addr_collection = _result_;
		addr_collection_length1 = _result__length1;
		for (addr_it = 0; addr_it < _result__length1; addr_it = addr_it + 1) {
			gchar* _tmp29_;
			gchar* addr;
			_tmp29_ = g_strdup (addr_collection[addr_it]);
			addr = _tmp29_;
			{
				fprintf (stdout, "%s\n", addr);
				_g_free0 (addr);
			}
		}
	}
	_result_ = (_vala_array_free (_result_, _result__length1, (GDestroyNotify) g_free), NULL);
	_g_string_free0 (querystr);
	queries = (g_free (queries), NULL);
}


static guint* _vala_array_dup1 (guint* self, int length) {
	return g_memdup (self, length * sizeof (guint));
}


static void address_matcher_mailaddress_freq_copy (const AddressMatcherMailAddress_freq* self, AddressMatcherMailAddress_freq* dest) {
	guint* _tmp0_;
	dest->address = g_strdup (self->address);
	dest->occurances = (_tmp0_ = self->occurances, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, (*self).occurances_length1));
	dest->occurances_length1 = self->occurances_length1;
}


static void address_matcher_mailaddress_freq_destroy (AddressMatcherMailAddress_freq* self) {
	_g_free0 ((*self).address);
	(*self).occurances = (g_free ((*self).occurances), NULL);
}


static AddressMatcherMailAddress_freq* address_matcher_mailaddress_freq_dup (const AddressMatcherMailAddress_freq* self) {
	AddressMatcherMailAddress_freq* dup;
	dup = g_new0 (AddressMatcherMailAddress_freq, 1);
	address_matcher_mailaddress_freq_copy (self, dup);
	return dup;
}


static void address_matcher_mailaddress_freq_free (AddressMatcherMailAddress_freq* self) {
	address_matcher_mailaddress_freq_destroy (self);
	g_free (self);
}


static GType address_matcher_mailaddress_freq_get_type (void) {
	static volatile gsize address_matcher_mailaddress_freq_type_id__volatile = 0;
	if (g_once_init_enter (&address_matcher_mailaddress_freq_type_id__volatile)) {
		GType address_matcher_mailaddress_freq_type_id;
		address_matcher_mailaddress_freq_type_id = g_boxed_type_register_static ("AddressMatcherMailAddress_freq", (GBoxedCopyFunc) address_matcher_mailaddress_freq_dup, (GBoxedFreeFunc) address_matcher_mailaddress_freq_free);
		g_once_init_leave (&address_matcher_mailaddress_freq_type_id__volatile, address_matcher_mailaddress_freq_type_id);
	}
	return address_matcher_mailaddress_freq_type_id__volatile;
}


static void value_address_matcher_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void value_address_matcher_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		address_matcher_unref (value->data[0].v_pointer);
	}
}


static void value_address_matcher_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = address_matcher_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer value_address_matcher_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* value_address_matcher_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		AddressMatcher* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = address_matcher_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* value_address_matcher_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	AddressMatcher** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = address_matcher_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* param_spec_address_matcher (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	ParamSpecAddressMatcher* spec;
	g_return_val_if_fail (g_type_is_a (object_type, TYPE_ADDRESS_MATCHER), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer value_get_address_matcher (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER), NULL);
	return value->data[0].v_pointer;
}


void value_set_address_matcher (GValue* value, gpointer v_object) {
	AddressMatcher* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_ADDRESS_MATCHER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		address_matcher_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		address_matcher_unref (old);
	}
}


void value_take_address_matcher (GValue* value, gpointer v_object) {
	AddressMatcher* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_ADDRESS_MATCHER));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_ADDRESS_MATCHER));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		address_matcher_unref (old);
	}
}


static void address_matcher_class_init (AddressMatcherClass * klass) {
	address_matcher_parent_class = g_type_class_peek_parent (klass);
	ADDRESS_MATCHER_CLASS (klass)->finalize = address_matcher_finalize;
	g_type_class_add_private (klass, sizeof (AddressMatcherPrivate));
}


static void address_matcher_instance_init (AddressMatcher * self) {
	self->priv = ADDRESS_MATCHER_GET_PRIVATE (self);
	self->priv->user_db_path = NULL;
	self->priv->user_primary_email = NULL;
	self->priv->user_addrbook_tag = NULL;
	self->ref_count = 1;
}


static void address_matcher_finalize (AddressMatcher* obj) {
	AddressMatcher * self;
	self = ADDRESS_MATCHER (obj);
	_notmuch_database_close0 (self->priv->db);
	_g_free0 (self->priv->user_db_path);
	_g_free0 (self->priv->user_primary_email);
	_g_free0 (self->priv->user_addrbook_tag);
}


GType address_matcher_get_type (void) {
	static volatile gsize address_matcher_type_id__volatile = 0;
	if (g_once_init_enter (&address_matcher_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { value_address_matcher_init, value_address_matcher_free_value, value_address_matcher_copy_value, value_address_matcher_peek_pointer, "p", value_address_matcher_collect_value, "p", value_address_matcher_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (AddressMatcherClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) address_matcher_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AddressMatcher), 0, (GInstanceInitFunc) address_matcher_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType address_matcher_type_id;
		address_matcher_type_id = g_type_register_fundamental (g_type_fundamental_next (), "AddressMatcher", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&address_matcher_type_id__volatile, address_matcher_type_id);
	}
	return address_matcher_type_id__volatile;
}


gpointer address_matcher_ref (gpointer instance) {
	AddressMatcher* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void address_matcher_unref (gpointer instance) {
	AddressMatcher* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		ADDRESS_MATCHER_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


gint _vala_main (gchar** args, int args_length1) {
	gint result = 0;
	AddressMatcher* _tmp0_ = NULL;
	AddressMatcher* app;
	_tmp0_ = address_matcher_new ();
	app = _tmp0_;
	address_matcher_run (app, args[1]);
	result = 0;
	_address_matcher_unref0 (app);
	return result;
}


int main (int argc, char ** argv) {
	g_type_init ();
	return _vala_main (argv, argc);
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}