text
stringlengths 13
91.1k
|
|---|
#ifndef RecoLocalMuon_GEMMaskReClusterizer_h
#define RecoLocalMuon_GEMMaskReClusterizer_h
/** \Class GEMMaskReClusterizer
* \author J.C. Sanabria -- UniAndes, Bogota
*/
#include "GEMEtaPartitionMask.h"
#include "GEMCluster.h"
#include "GEMClusterizer.h"
#include "GEMClusterContainer.h"
#include "DataFormats/MuonDetId/interface/GEMDetId.h"
class GEMMaskReClusterizer
{
public :
GEMMaskReClusterizer();
~GEMMaskReClusterizer();
GEMClusterContainer doAction(const GEMDetId& ,GEMClusterContainer& , const EtaPartitionMask& );
int get(const EtaPartitionMask& ,int );
};
#endif
|
#include "aoip/pcap.h"
void build_pcap_global_hdr(struct pcap_global_hdr *hdr)
{
hdr->magic_number = PCAP_MAGIC_NANOSEC;
hdr->version_major = PCAP_VERSION_MAJOR;
hdr->version_minor = PCAP_VERSION_MINOR;
hdr->thiszone = 0;
hdr->sigfigs = 0;
hdr->snaplen = PCAP_SNAPLEN;
hdr->network = 0;
}
void build_pcaprec_hdr(struct pcaprec_hdr *hdr)
{
hdr->ts_sec = 0;
hdr->ts_usec = 0;
hdr->incl_len = 0;
hdr->orig_len = 0;
}
|
// License: Apache 2.0. See LICENSE file in root directory.
// Copyright(c) 2017 Intel Corporation. All Rights Reserved.
#pragma once
#include "../usb/usb-device.h"
#include "../usb/usb-enumerator.h"
#include "../types.h"
#ifdef WITH_TRACKING
#include "common/fw/target.h"
#endif
namespace librealsense {
namespace platform {
#ifdef WITH_TRACKING
bool tm_boot(const std::vector<usb_device_info> & devices)
{
bool found = false;
for(const auto & device_info : devices) {
if(device_info.vid == 0x03E7 && device_info.pid == 0x2150) {
LOG_INFO("Found a T265 to boot");
found = true;
auto dev = usb_enumerator::create_usb_device(device_info);
const auto& m = dev->open(0);
// transfer the firmware data
int size;
auto target_hex = fw_get_target(size);
if(!target_hex)
LOG_ERROR("librealsense failed to get T265 FW resource");
auto iface = dev->get_interface(0);
auto endpoint = iface->first_endpoint(RS2_USB_ENDPOINT_DIRECTION_WRITE);
uint32_t transfered = 0;
auto status = m->bulk_transfer(endpoint, const_cast<uint8_t*>(target_hex), static_cast<uint32_t>(size), transfered, 1000);
if(status != RS2_USB_STATUS_SUCCESS)
LOG_ERROR("Error booting T265");
}
}
return found;
}
#else
bool tm_boot(const std::vector<usb_device_info> & devices)
{
return false;
}
#endif
}
}
|
/* $Id$ */
#include <stdio.h>
#include <stdlib.h>
#include "mpi.h"
#include "star.h"
int comm_world_rank, comm_world_size;
char *buffer;
void ping( int minsize, int maxsize, int repeats )
{
int to, msg, size;
double time;
MPI_Status status;
/* communicate with any other process in MPI_COMM_WORLD */
for( to = 0; to < comm_world_size; to++ ) {
if( to != comm_world_rank ) {
printf( "Measuring pingpong performance from %d to %d; minsize = %d, maxsize = %d, repeats = %d\n\n",
comm_world_rank, to, minsize, maxsize, repeats );
printf( "Message Size [Byte]\t\tBandwidth [MB/s]\t\t\tLatency [us]\n" );
printf( "================================================================================================================\n" );
for( size = minsize; size <= maxsize; size *= 2 ) {
/* synchronize with communication partner */
MPI_Sendrecv(buffer, size, MPI_CHAR, to, 3, buffer, size, MPI_CHAR, to, 3, MPI_COMM_WORLD, &status );
time = MPI_Wtime();
for( msg = 0; msg < repeats; msg++ ) {
MPI_Send( buffer, size, MPI_CHAR, to, 1, MPI_COMM_WORLD );
MPI_Recv( buffer, size, MPI_CHAR, to, 2, MPI_COMM_WORLD, &status );
}
time = MPI_Wtime() - time;
printf( "%10d\t\t\t%10.3f\t\t\t\t%10.3f\n", size, (2*size*repeats)/(time*1024*1024), (time*1e+6)/(repeats*2) );
fflush( stdout );
}
printf( "\n\n\n" );
}
}
}
void pong( int center, int minsize, int maxsize, int repeats )
{
int msg, size;
MPI_Status status;
for( size = minsize; size <= maxsize; size *= 2 ) {
/* synchronize with communication partner */
MPI_Sendrecv( buffer, size, MPI_CHAR, center, 3, buffer, size, MPI_CHAR, center, 3, MPI_COMM_WORLD, &status );
for( msg = 0; msg < repeats; msg++ ) {
MPI_Recv( buffer, size, MPI_CHAR, center, 1, MPI_COMM_WORLD, &status );
MPI_Send( buffer, size, MPI_CHAR, center, 2, MPI_COMM_WORLD );
}
}
}
void star( int center, int minsize, int maxsize, int repeats )
{
int new_center, new_minsize, new_maxsize, new_repeats;
MPI_Comm_size( MPI_COMM_WORLD, &comm_world_size );
MPI_Comm_rank( MPI_COMM_WORLD, &comm_world_rank );
new_minsize = (minsize == -1) ? STAR_MINSIZE_DEFAULT : minsize;
new_maxsize = (maxsize == -1) ? STAR_MAXSIZE_DEFAULT : maxsize;
new_repeats = (repeats == -1) ? STAR_REPEATS_DEFAULT : repeats;
buffer = (char *)malloc( new_maxsize * sizeof(char) );
if( center != -1 ) {
if( comm_world_rank == center )
ping( new_minsize, new_maxsize, new_repeats );
else
pong( center, new_minsize, new_maxsize, new_repeats );
}
else {
for( new_center = 0; new_center < comm_world_size; new_center++ ) {
if( comm_world_rank == new_center )
ping( new_minsize, new_maxsize, new_repeats );
else
pong( new_center, new_minsize, new_maxsize, new_repeats );
}
}
free( buffer );
}
|
int missingNumber(int *nums, int numsSize) {
int i;
unsigned long long sum;
for (i = 0, sum = 0; i != numsSize; i++) {
sum += nums[i];
}
return numsSize * (numsSize + 1) / 2 - sum;
}
|
/* Sang Ouk Kim
* Ethan Anderon
* cse374 - hw6 - 05/18/17
*
* print_heap.c is the implementation of a fucntion that prints a formatted listing
* of the free list memory blocks for a memory managemnt program built for a cse374
* homework assignment.
*/
#include "mem_impl.h"
#include <inttypes.h>
// print_heap prints a formatted listing on file f showing the address and length of each
// block on the free list on a single output line.
void print_heap(FILE * f) {
fprintf(f, "=== PRINTING HEAP ===\n\n");
Block *curr = head;
while (curr != NULL) {
// fprint to the file and memory
fprintf(f,"address: 0x%" PRIuPTR " length: 0x%" PRIuPTR " address end: 0x%" PRIuPTR "\n", (uintptr_t)curr, curr->size + BLOCK_SIZE, (uintptr_t)curr + curr->size + BLOCK_SIZE);
curr = curr->next;
}
}
|
/*
* The input core
*
* Copyright (c) 1999-2002 Vojtech Pavlik
*/
/*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*/
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/smp_lock.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/major.h>
#include <linux/pm.h>
#include <linux/proc_fs.h>
#include <linux/kmod.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <linux/device.h>
#include <linux/devfs_fs_kernel.h>
MODULE_AUTHOR("Vojtech Pavlik <[email protected]>");
MODULE_DESCRIPTION("Input core");
MODULE_LICENSE("GPL");
EXPORT_SYMBOL(input_register_device);
EXPORT_SYMBOL(input_unregister_device);
EXPORT_SYMBOL(input_register_handler);
EXPORT_SYMBOL(input_unregister_handler);
EXPORT_SYMBOL(input_grab_device);
EXPORT_SYMBOL(input_release_device);
EXPORT_SYMBOL(input_open_device);
EXPORT_SYMBOL(input_close_device);
EXPORT_SYMBOL(input_accept_process);
EXPORT_SYMBOL(input_flush_device);
EXPORT_SYMBOL(input_event);
EXPORT_SYMBOL(input_class);
#define INPUT_DEVICES 256
static LIST_HEAD(input_dev_list);
static LIST_HEAD(input_handler_list);
static struct input_handler *input_table[8];
#ifdef CONFIG_PROC_FS
static struct proc_dir_entry *proc_bus_input_dir;
DECLARE_WAIT_QUEUE_HEAD(input_devices_poll_wait);
static int input_devices_state;
#endif
static inline unsigned int ms_to_jiffies(unsigned int ms)
{
unsigned int j;
j = (ms * HZ + 500) / 1000;
return (j > 0) ? j : 1;
}
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
struct input_handle *handle;
if (dev->pm_dev)
pm_access(dev->pm_dev);
if (type > EV_MAX || !test_bit(type, dev->evbit))
return;
add_mouse_randomness((type << 4) ^ code ^ (code >> 4) ^ value);
switch (type) {
case EV_SYN:
switch (code) {
case SYN_CONFIG:
if (dev->event) dev->event(dev, type, code, value);
break;
case SYN_REPORT:
if (dev->sync) return;
dev->sync = 1;
break;
}
break;
case EV_KEY:
if (code > KEY_MAX || !test_bit(code, dev->keybit) || !!test_bit(code, dev->key) == value)
return;
if (value == 2)
break;
change_bit(code, dev->key);
if (test_bit(EV_REP, dev->evbit) && dev->rep[REP_PERIOD] && dev->timer.data && value) {
dev->repeat_key = code;
mod_timer(&dev->timer, jiffies + ms_to_jiffies(dev->rep[REP_DELAY]));
}
break;
case EV_ABS:
if (code > ABS_MAX || !test_bit(code, dev->absbit))
return;
if (dev->absfuzz[code]) {
if ((value > dev->abs[code] - (dev->absfuzz[code] >> 1)) &&
(value < dev->abs[code] + (dev->absfuzz[code] >> 1)))
return;
if ((value > dev->abs[code] - dev->absfuzz[code]) &&
(value < dev->abs[code] + dev->absfuzz[code]))
value = (dev->abs[code] * 3 + value) >> 2;
if ((value > dev->abs[code] - (dev->absfuzz[code] << 1)) &&
(value < dev->abs[code] + (dev->absfuzz[code] << 1)))
value = (dev->abs[code] + value) >> 1;
}
if (dev->abs[code] == value)
return;
dev->abs[code] = value;
break;
case EV_REL:
if (code > REL_MAX || !test_bit(code, dev->relbit) || (value == 0))
return;
break;
case EV_MSC:
if (code > MSC_MAX || !test_bit(code, dev->mscbit))
return;
if (dev->event) dev->event(dev, type, code, value);
break;
case EV_LED:
if (code > LED_MAX || !test_bit(code, dev->ledbit) || !!test_bit(code, dev->led) == value)
return;
change_bit(code, dev->led);
if (dev->event) dev->event(dev, type, code, value);
break;
case EV_SND:
if (code > SND_MAX || !test_bit(code, dev->sndbit))
return;
if (dev->event) dev->event(dev, type, code, value);
break;
case EV_REP:
if (code > REP_MAX || value < 0 || dev->rep[code] == value) return;
dev->rep[code] = value;
if (dev->event) dev->event(dev, type, code, value);
break;
case EV_FF:
if (dev->event) dev->event(dev, type, code, value);
break;
}
if (type != EV_SYN)
dev->sync = 0;
if (dev->grab)
dev->grab->handler->event(dev->grab, type, code, value);
else
list_for_each_entry(handle, &dev->h_list, d_node)
if (handle->open)
handle->handler->event(handle, type, code, value);
}
static void input_repeat_key(unsigned long data)
{
struct input_dev *dev = (void *) data;
if (!test_bit(dev->repeat_key, dev->key))
return;
input_event(dev, EV_KEY, dev->repeat_key, 2);
input_sync(dev);
mod_timer(&dev->timer, jiffies + ms_to_jiffies(dev->rep[REP_PERIOD]));
}
int input_accept_process(struct input_handle *handle, struct file *file)
{
if (handle->dev->accept)
return handle->dev->accept(handle->dev, file);
return 0;
}
int input_grab_device(struct input_handle *handle)
{
if (handle->dev->grab)
return -EBUSY;
handle->dev->grab = handle;
return 0;
}
void input_release_device(struct input_handle *handle)
{
if (handle->dev->grab == handle)
handle->dev->grab = NULL;
}
int input_open_device(struct input_handle *handle)
{
if (handle->dev->pm_dev)
pm_access(handle->dev->pm_dev);
handle->open++;
if (handle->dev->open)
return handle->dev->open(handle->dev);
return 0;
}
int input_flush_device(struct input_handle* handle, struct file* file)
{
if (handle->dev->flush)
return handle->dev->flush(handle->dev, file);
return 0;
}
void input_close_device(struct input_handle *handle)
{
input_release_device(handle);
if (handle->dev->pm_dev)
pm_dev_idle(handle->dev->pm_dev);
if (handle->dev->close)
handle->dev->close(handle->dev);
handle->open--;
}
static void input_link_handle(struct input_handle *handle)
{
list_add_tail(&handle->d_node, &handle->dev->h_list);
list_add_tail(&handle->h_node, &handle->handler->h_list);
}
#define MATCH_BIT(bit, max) \
for (i = 0; i < NBITS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != NBITS(max)) \
continue;
static struct input_device_id *input_match_device(struct input_device_id *id, struct input_dev *dev)
{
int i;
for (; id->flags || id->driver_info; id++) {
if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
if (id->id.bustype != dev->id.bustype)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
if (id->id.vendor != dev->id.vendor)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
if (id->id.product != dev->id.product)
continue;
if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
if (id->id.version != dev->id.version)
continue;
MATCH_BIT(evbit, EV_MAX);
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
return id;
}
return NULL;
}
/*
* Input hotplugging interface - loading event handlers based on
* device bitfields.
*/
#ifdef CONFIG_HOTPLUG
/*
* Input hotplugging invokes what /proc/sys/kernel/hotplug says
* (normally /sbin/hotplug) when input devices get added or removed.
*
* This invokes a user mode policy agent, typically helping to load driver
* or other modules, configure the device, and more. Drivers can provide
* a MODULE_DEVICE_TABLE to help with module loading subtasks.
*
*/
#define SPRINTF_BIT_A(bit, name, max) \
do { \
envp[i++] = scratch; \
scratch += sprintf(scratch, name); \
for (j = NBITS(max) - 1; j >= 0; j--) \
if (dev->bit[j]) break; \
for (; j >= 0; j--) \
scratch += sprintf(scratch, "%lx ", dev->bit[j]); \
scratch++; \
} while (0)
#define SPRINTF_BIT_A2(bit, name, max, ev) \
do { \
if (test_bit(ev, dev->evbit)) \
SPRINTF_BIT_A(bit, name, max); \
} while (0)
static void input_call_hotplug(char *verb, struct input_dev *dev)
{
char *argv[3], **envp, *buf, *scratch;
int i = 0, j, value;
if (!hotplug_path[0]) {
printk(KERN_ERR "input.c: calling hotplug without a hotplug agent defined\n");
return;
}
if (in_interrupt()) {
printk(KERN_ERR "input.c: calling hotplug from interrupt\n");
return;
}
if (!current->fs->root) {
printk(KERN_WARNING "input.c: calling hotplug without valid filesystem\n");
return;
}
if (!(envp = (char **) kmalloc(20 * sizeof(char *), GFP_KERNEL))) {
printk(KERN_ERR "input.c: not enough memory allocating hotplug environment\n");
return;
}
if (!(buf = kmalloc(1024, GFP_KERNEL))) {
kfree (envp);
printk(KERN_ERR "input.c: not enough memory allocating hotplug environment\n");
return;
}
argv[0] = hotplug_path;
argv[1] = "input";
argv[2] = 0;
envp[i++] = "HOME=/";
envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
scratch = buf;
envp[i++] = scratch;
scratch += sprintf(scratch, "ACTION=%s", verb) + 1;
envp[i++] = scratch;
scratch += sprintf(scratch, "PRODUCT=%x/%x/%x/%x",
dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version) + 1;
if (dev->name) {
envp[i++] = scratch;
scratch += sprintf(scratch, "NAME=%s", dev->name) + 1;
}
if (dev->phys) {
envp[i++] = scratch;
scratch += sprintf(scratch, "PHYS=%s", dev->phys) + 1;
}
SPRINTF_BIT_A(evbit, "EV=", EV_MAX);
SPRINTF_BIT_A2(keybit, "KEY=", KEY_MAX, EV_KEY);
SPRINTF_BIT_A2(relbit, "REL=", REL_MAX, EV_REL);
SPRINTF_BIT_A2(absbit, "ABS=", ABS_MAX, EV_ABS);
SPRINTF_BIT_A2(mscbit, "MSC=", MSC_MAX, EV_MSC);
SPRINTF_BIT_A2(ledbit, "LED=", LED_MAX, EV_LED);
SPRINTF_BIT_A2(sndbit, "SND=", SND_MAX, EV_SND);
SPRINTF_BIT_A2(ffbit, "FF=", FF_MAX, EV_FF);
envp[i++] = 0;
#ifdef INPUT_DEBUG
printk(KERN_DEBUG "input.c: calling %s %s [%s %s %s %s %s]\n",
argv[0], argv[1], envp[0], envp[1], envp[2], envp[3], envp[4]);
#endif
value = call_usermodehelper(argv [0], argv, envp, 0);
kfree(buf);
kfree(envp);
#ifdef INPUT_DEBUG
if (value != 0)
printk(KERN_DEBUG "input.c: hotplug returned %d\n", value);
#endif
}
#endif
void input_register_device(struct input_dev *dev)
{
struct input_handle *handle;
struct input_handler *handler;
struct input_device_id *id;
set_bit(EV_SYN, dev->evbit);
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
INIT_LIST_HEAD(&dev->h_list);
list_add_tail(&dev->node, &input_dev_list);
list_for_each_entry(handler, &input_handler_list, node)
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
#ifdef CONFIG_HOTPLUG
input_call_hotplug("add", dev);
#endif
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
void input_unregister_device(struct input_dev *dev)
{
struct list_head * node, * next;
if (!dev) return;
if (dev->pm_dev)
pm_unregister(dev->pm_dev);
del_timer_sync(&dev->timer);
list_for_each_safe(node, next, &dev->h_list) {
struct input_handle * handle = to_handle(node);
list_del_init(&handle->d_node);
list_del_init(&handle->h_node);
handle->handler->disconnect(handle);
}
#ifdef CONFIG_HOTPLUG
input_call_hotplug("remove", dev);
#endif
list_del_init(&dev->node);
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
void input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
struct input_handle *handle;
struct input_device_id *id;
if (!handler) return;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = handler;
list_add_tail(&handler->node, &input_handler_list);
list_for_each_entry(dev, &input_dev_list, node)
if ((id = input_match_device(handler->id_table, dev)))
if ((handle = handler->connect(handler, dev, id)))
input_link_handle(handle);
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
void input_unregister_handler(struct input_handler *handler)
{
struct list_head * node, * next;
list_for_each_safe(node, next, &handler->h_list) {
struct input_handle * handle = to_handle_h(node);
list_del_init(&handle->h_node);
list_del_init(&handle->d_node);
handler->disconnect(handle);
}
list_del_init(&handler->node);
if (handler->fops != NULL)
input_table[handler->minor >> 5] = NULL;
#ifdef CONFIG_PROC_FS
input_devices_state++;
wake_up(&input_devices_poll_wait);
#endif
}
static int input_open_file(struct inode *inode, struct file *file)
{
struct input_handler *handler = input_table[iminor(inode) >> 5];
struct file_operations *old_fops, *new_fops = NULL;
int err;
/* No load-on-demand here? */
if (!handler || !(new_fops = fops_get(handler->fops)))
return -ENODEV;
/*
* That's _really_ odd. Usually NULL ->open means "nothing special",
* not "no device". Oh, well...
*/
if (!new_fops->open) {
fops_put(new_fops);
return -ENODEV;
}
old_fops = file->f_op;
file->f_op = new_fops;
err = new_fops->open(inode, file);
if (err) {
fops_put(file->f_op);
file->f_op = fops_get(old_fops);
}
fops_put(old_fops);
return err;
}
static struct file_operations input_fops = {
.owner = THIS_MODULE,
.open = input_open_file,
};
#ifdef CONFIG_PROC_FS
#define SPRINTF_BIT_B(bit, name, max) \
do { \
len += sprintf(buf + len, "B: %s", name); \
for (i = NBITS(max) - 1; i >= 0; i--) \
if (dev->bit[i]) break; \
for (; i >= 0; i--) \
len += sprintf(buf + len, "%lx ", dev->bit[i]); \
len += sprintf(buf + len, "\n"); \
} while (0)
#define SPRINTF_BIT_B2(bit, name, max, ev) \
do { \
if (test_bit(ev, dev->evbit)) \
SPRINTF_BIT_B(bit, name, max); \
} while (0)
static unsigned int input_devices_poll(struct file *file, poll_table *wait)
{
int state = input_devices_state;
poll_wait(file, &input_devices_poll_wait, wait);
if (state != input_devices_state)
return POLLIN | POLLRDNORM;
return 0;
}
static int input_devices_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
{
struct input_dev *dev;
struct input_handle *handle;
off_t at = 0;
int i, len, cnt = 0;
list_for_each_entry(dev, &input_dev_list, node) {
len = sprintf(buf, "I: Bus=%04x Vendor=%04x Product=%04x Version=%04x\n",
dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
len += sprintf(buf + len, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
len += sprintf(buf + len, "P: Phys=%s\n", dev->phys ? dev->phys : "");
len += sprintf(buf + len, "H: Handlers=");
list_for_each_entry(handle, &dev->h_list, d_node)
len += sprintf(buf + len, "%s ", handle->name);
len += sprintf(buf + len, "\n");
SPRINTF_BIT_B(evbit, "EV=", EV_MAX);
SPRINTF_BIT_B2(keybit, "KEY=", KEY_MAX, EV_KEY);
SPRINTF_BIT_B2(relbit, "REL=", REL_MAX, EV_REL);
SPRINTF_BIT_B2(absbit, "ABS=", ABS_MAX, EV_ABS);
SPRINTF_BIT_B2(mscbit, "MSC=", MSC_MAX, EV_MSC);
SPRINTF_BIT_B2(ledbit, "LED=", LED_MAX, EV_LED);
SPRINTF_BIT_B2(sndbit, "SND=", SND_MAX, EV_SND);
SPRINTF_BIT_B2(ffbit, "FF=", FF_MAX, EV_FF);
len += sprintf(buf + len, "\n");
at += len;
if (at >= pos) {
if (!*start) {
*start = buf + (pos - (at - len));
cnt = at - pos;
} else cnt += len;
buf += len;
if (cnt >= count)
break;
}
}
if (&dev->node == &input_dev_list)
*eof = 1;
return (count > cnt) ? cnt : count;
}
static int input_handlers_read(char *buf, char **start, off_t pos, int count, int *eof, void *data)
{
struct input_handler *handler;
off_t at = 0;
int len = 0, cnt = 0;
int i = 0;
list_for_each_entry(handler, &input_handler_list, node) {
if (handler->fops)
len = sprintf(buf, "N: Number=%d Name=%s Minor=%d\n",
i++, handler->name, handler->minor);
else
len = sprintf(buf, "N: Number=%d Name=%s\n",
i++, handler->name);
at += len;
if (at >= pos) {
if (!*start) {
*start = buf + (pos - (at - len));
cnt = at - pos;
} else cnt += len;
buf += len;
if (cnt >= count)
break;
}
}
if (&handler->node == &input_handler_list)
*eof = 1;
return (count > cnt) ? cnt : count;
}
static int __init input_proc_init(void)
{
struct proc_dir_entry *entry;
proc_bus_input_dir = proc_mkdir("input", proc_bus);
if (proc_bus_input_dir == NULL)
return -ENOMEM;
proc_bus_input_dir->owner = THIS_MODULE;
entry = create_proc_read_entry("devices", 0, proc_bus_input_dir, input_devices_read, NULL);
if (entry == NULL) {
remove_proc_entry("input", proc_bus);
return -ENOMEM;
}
entry->owner = THIS_MODULE;
entry->proc_fops->poll = input_devices_poll;
entry = create_proc_read_entry("handlers", 0, proc_bus_input_dir, input_handlers_read, NULL);
if (entry == NULL) {
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
return -ENOMEM;
}
entry->owner = THIS_MODULE;
return 0;
}
#else /* !CONFIG_PROC_FS */
static inline int input_proc_init(void) { return 0; }
#endif
struct class input_class = {
.name = "input",
};
static int __init input_init(void)
{
int retval = -ENOMEM;
class_register(&input_class);
input_proc_init();
retval = register_chrdev(INPUT_MAJOR, "input", &input_fops);
if (retval) {
printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
return retval;
}
retval = devfs_mk_dir("input");
if (retval) {
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
unregister_chrdev(INPUT_MAJOR, "input");
}
return retval;
}
static void __exit input_exit(void)
{
remove_proc_entry("devices", proc_bus_input_dir);
remove_proc_entry("handlers", proc_bus_input_dir);
remove_proc_entry("input", proc_bus);
devfs_remove("input");
unregister_chrdev(INPUT_MAJOR, "input");
class_unregister(&input_class);
}
subsys_initcall(input_init);
module_exit(input_exit);
|
/**
* @file crc16_table_gen.c
*
* main() for a program which generates a C language uint16_t[256] table
* for use in byte-wise CRC-16 calculations.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <errno.h>
#include "crc16.h"
static void usage(char const *program_name)
{
fprintf(stderr, "usage: %s polynomial\n", program_name);
fprintf(stderr, "\texample: for CRC-16-CCITT use 0x1021\n");
fprintf(stderr, "\t%s 0x1021\n", program_name);
fprintf(stderr, "\n");
}
static void crc16_table_print(FILE *fout, uint16_t const *crc16_table, uint16_t crc16_poly)
{
fprintf(fout, "uint16_t const crc16_table_0x%04x[] = {", crc16_poly);
for (size_t index = 0; index < 256u; ++index) {
if (index % 8 == 0) {
fprintf(fout, "\n\t");
}
fprintf(fout, "0x%04x, ", crc16_table[index]);
}
fprintf(fout, "\n};");
fprintf(fout, "\n");
}
int main(int argc, char const **argv)
{
int error = 0;
// All zeroes on the polynomial is uninteresting.
// Use that case as the default.
uint16_t crc16_poly = 0x0000;
for (int argv_index = 0; argv_index < argc; ++argv_index) {
if (*argv[argv_index] == '-') { // Treat dash as an option.
switch (argv[argv_index][1]) { // Parse options.
default:
fprintf(stderr, "error: unknown argument: '%s'\n", argv[argv_index]);
usage(argv[0]);
error = EINVAL;
break;
}
} else {
// Treat the 'bare' argument as the polynomial.
crc16_poly = (uint16_t) strtoul(argv[argv_index], NULL, 0);
}
}
fprintf(stderr, "Using polynomial: 0x%04x\n", crc16_poly);
if (crc16_poly == 0x0000) {
usage(argv[0]); // Looks like someone forgot their polynomial.
error = EINVAL;
}
uint16_t crc16_table[256];
crc16_table_init(crc16_table, crc16_poly);
crc16_table_print(stdout, crc16_table, crc16_poly);
return error;
}
|
/**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/SportsTrainer.framework/SportsTrainer
*/
#import <SportsTrainer/XXUnknownSuperclass.h>
#import <SportsTrainer/SportsTrainer-Structs.h>
@class UIGradient, UIColor;
@interface STRoundedGradientBackroundView : XXUnknownSuperclass {
UIColor *_topColor; // 48 = 0x30
UIColor *_bottomColor; // 52 = 0x34
UIColor *_borderColor; // 56 = 0x38
UIGradient *_gradient; // 60 = 0x3c
}
@property(retain, nonatomic) UIColor *borderColor; // G=0x11509; S=0x11069; @synthesize=_borderColor
@property(retain, nonatomic) UIColor *bottomColor; // G=0x114f9; S=0x11001; @synthesize=_bottomColor
@property(retain, nonatomic) UIColor *topColor; // G=0x114e9; S=0x10f99; @synthesize=_topColor
// declared property getter: - (id)borderColor; // 0x11509
// declared property getter: - (id)bottomColor; // 0x114f9
// declared property getter: - (id)topColor; // 0x114e9
- (void)_invalidateGradient; // 0x114bd
- (id)_gradient; // 0x111e1
- (void)drawRect:(CGRect)rect; // 0x110c1
// declared property setter: - (void)setBorderColor:(id)color; // 0x11069
// declared property setter: - (void)setBottomColor:(id)color; // 0x11001
// declared property setter: - (void)setTopColor:(id)color; // 0x10f99
- (void)dealloc; // 0x10f11
- (id)initWithFrame:(CGRect)frame; // 0x10ec1
@end
|
#ifndef VTKIMAGINGOPENGL2_EXPORT_H
#define VTKIMAGINGOPENGL2_EXPORT_H
#ifdef VTKIMAGINGOPENGL2_STATIC_DEFINE
# define VTKIMAGINGOPENGL2_EXPORT
# define VTKIMAGINGOPENGL2_NO_EXPORT
#else
# ifndef VTKIMAGINGOPENGL2_EXPORT
# ifdef vtkImagingOpenGL2_EXPORTS
/* We are building this library */
# define VTKIMAGINGOPENGL2_EXPORT __declspec(dllexport)
# else
/* We are using this library */
# define VTKIMAGINGOPENGL2_EXPORT __declspec(dllimport)
# endif
# endif
# ifndef VTKIMAGINGOPENGL2_NO_EXPORT
# define VTKIMAGINGOPENGL2_NO_EXPORT
# endif
#endif
#ifndef VTKIMAGINGOPENGL2_DEPRECATED
# define VTKIMAGINGOPENGL2_DEPRECATED __declspec(deprecated)
# define VTKIMAGINGOPENGL2_DEPRECATED_EXPORT VTKIMAGINGOPENGL2_EXPORT __declspec(deprecated)
# define VTKIMAGINGOPENGL2_DEPRECATED_NO_EXPORT VTKIMAGINGOPENGL2_NO_EXPORT __declspec(deprecated)
#endif
#define DEFINE_NO_DEPRECATED 0
#if DEFINE_NO_DEPRECATED
# define VTKIMAGINGOPENGL2_NO_DEPRECATED
#endif
/* AutoInit dependencies. */
#include "vtkRenderingOpenGL2Module.h"
#endif
|
//
// MBPoiTypeManager.h
// iNaviCore
//
// Created by fanwei on 1/28/13.
// Copyright (c) 2013 Mapbar. All rights reserved.
//
#import "MBPoiTypeObject.h"
/**
* POI类型管理类
*/
@interface MBPoiTypeManager : NSObject
/**
* 返回默认的 MBPoiTypeManager,需要先初始化 MBPoiQuery 和 MBWorldManager。
*/
+ (MBPoiTypeManager *)defaultPoiTypeManager;
/**
* 返回表示"周边快捷类型"的POI类型对象,即,整个POI类型树的根节点
* @return POI类型树的根节点对象
*/
- (MBPoiTypeObject *)rootPoiTypeObject;
/**
* 返回表示"周边更多类型"的POI类型对象
* @return POI类型对象
*/
- (MBPoiTypeObject *)rootKeyQueryPoiTypeObject;
/**
* 返回表示"周边快捷类型"的POI类型索引值,即,整个POI类型树的根节点
* @return POI类型树的根节点ID
*/
- (MBPoiTypeIndex) getRoot;
/**
* 获取POI类型树中指定节点的第一个子节点Id
* @param index 指定POI节点ID
* @return 第一个子节点ID
*/
- (MBPoiTypeIndex) getFirstChildId:(MBPoiTypeIndex)index;
/**
* 获取类型树中指定节点的下一个兄弟节点
* @param index 指定POI节点ID
* @return 兄弟节点ID
*/
- (MBPoiTypeIndex) getNextSibling:(MBPoiTypeIndex)index;
/**
* 获取POI类型树中指定节点的父节点
* @param index 指定POI节点ID
* @return 父节点ID
*/
- (MBPoiTypeIndex) getParent:(MBPoiTypeIndex)index;
/**
* 获取POI类型树中的节点总数
* @return 获取到无效结果,则返回-1
*/
- (NSInteger) getObjectNumber;
/**
* 返回POI类型树中具有指定名称的节点ID,由于不同数据中的类型名称会有所差异,所以最好不要使用这个方法
* @param name 类型名称
* @return POI类型ID
*/
- (MBPoiTypeIndex) getIndexByName:(NSString *)name;
/**
* 返回表示"周边更多类型"的POI类型索引
* @return POI类型索引
*/
- (MBPoiTypeIndex) getKeyQueryTypeRoot;
/**
* 获取指定的POI类型码在类型树"周边更多类型"节点之下对应的节点索引
* @param type 指定的POI类型码
* @return POI类型索引
*/
- (MBPoiTypeIndex) getIndexByType:(MBPoiType)type;
/**
* 获取指定 POI 类型码对应的类型名称
*
* @param typeCode MBPoiType
*
* @return POI类型名称
*/
- (NSString *) getTypeName:(MBPoiType)typeCode;
/**
* 获取 POI 类型树中指定节点所包含的 POI 类型码
*
* @param index POI类型索引
*
* @return MBPoiType
*/
- (NSArray *) getNaviInfoIds:(MBPoiTypeIndex)index;
/**
* 根据 MBPoiTypeIndex 得到当前 MBPoiType 下的子节点
*
* @param index 当前 MBPoiType 的 index
*
* @return <MBPoiTypeObject>
*/
- (NSArray*) getChildNodes:(MBPoiTypeIndex)index;
@end
|
//
// MBPrefs.h
// matchbook
//
// Created by guangbool on 2017/7/17.
// Copyright © 2017年 devbool. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import "MBConstants.h"
// 保存各项设置值的 key
extern NSString *MBProgramLiveAutoRefreshIntervalStoreIdentifier;
extern NSString *MBProgramListOperateItemsPostionStoreIdentifier;
extern NSString *MBListDayDateSectionHeaderFixedStoreIdentifier;
extern NSString *MBProgramRemindTimeStoreIdentifier;
extern NSString *MBRememberLastOpenedListTypeStoreIdentifier;
extern NSString *MBListDisplayNumInExpandedWidgetStoreIdentifier;
extern NSString *MBUseTapticPeekStoreIdentifier;
extern NSString *MBClickWidgetProgramItemShowDetail;
@interface MBPrefs : NSObject
+ (instancetype)shared;
/**
直播情况(比分)自动更新频率
*/
@property (nonatomic, assign) MBProgramLiveAutoRefreshInterval liveAutoRefreshInterval;
/**
重置'直播情况(比分)自动更新频率'
@return 重置后的值
*/
- (MBProgramLiveAutoRefreshInterval)resetLiveAutoRefreshInterval;
/**
节目列表操作项(刷新、到直播按钮)位置
*/
@property (nonatomic, assign) MBProgramListOperateItemsPostion listOperateItemsPosition;
/**
重置'节目列表操作项(刷新、到直播按钮)位置'
@return 重置后的值
*/
- (MBProgramListOperateItemsPostion)resetListOperateItemsPosition;
/**
是否固定节目列表的日期头
*/
@property (nonatomic, assign) BOOL listDayDateSectionHeaderFixed;
/**
重置'是否固定节目列表的日期头'
@return 重置后的值
*/
- (BOOL)resetListDayDateSectionHeaderFixed;
/**
节目提醒时间
*/
@property (nonatomic, assign) MBProgramRemindTime programRemindTime;
/**
重置'节目提醒时间'
@return 重置后的值
*/
- (MBProgramRemindTime)resetProgramRemindTime;
/**
记住上一次打开的节目列表类型
*/
@property (nonatomic, assign) BOOL rememberLastOpenedListType;
/**
重置'记住上一次打开的节目列表类型'
@return 重置后的值
*/
- (BOOL)resetRememberLastOpenedListType;
/**
上一次打开的节目列表类型。 如果不存在,则返回 NSNotFound
*/
@property (nonatomic, assign) NSInteger lastOpenedListType;
/**
Widget展开显示节目数量
*/
@property (nonatomic, assign) MBListDisplayNumInExpandedWidget listDisplayNumInExpandedWidget;
/**
重置'Widget展开显示节目数量'
@return 重置后的值
*/
- (MBListDisplayNumInExpandedWidget)resetListDisplayNumInExpandedWidget;
/**
是否启用触感反馈
*/
@property (nonatomic, assign) BOOL useTapticPeek;
/**
重置'是否启用触感反馈'
@return 重置后的值
*/
- (BOOL)resetUseTapticPeek;
/**
Widget的节目点击后是否详情
*/
@property (nonatomic, assign) BOOL clickWidgetProgramItemShowDetail;
/**
重置'Widget的节目点击后是否详情'
@return 重置后的值
*/
- (BOOL)resetClickWidgetProgramItemShowDetail;
@end
@interface UITraitCollection (MBPrefs)
- (BOOL)tapticPeekIfPossible;
@end
|
//
// banshee-player-missing-elements.h
//
// Author:
// Aaron Bockover <[email protected]>
//
// Copyright (C) 2005-2008 Novell, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#ifndef _BANSHEE_PLAYER_MISSING_ELEMENTS_H
#define _BANSHEE_PLAYER_MISSING_ELEMENTS_H
#include "banshee-player-private.h"
void _bp_missing_elements_destroy (BansheePlayer *player);
void _bp_missing_elements_process_message (BansheePlayer *player, GstMessage *message);
void _bp_missing_elements_handle_state_changed (BansheePlayer *player, GstState old, GstState new);
#endif /* _BANSHEE_PLAYER_MISSING_ELEMENTS_H */
|
/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
/* Copyright (c) 2021 Facebook */
#ifndef __BPF_GEN_INTERNAL_H
#define __BPF_GEN_INTERNAL_H
struct ksym_relo_desc {
const char *name;
int kind;
int insn_idx;
};
struct bpf_gen {
struct gen_loader_opts *opts;
void *data_start;
void *data_cur;
void *insn_start;
void *insn_cur;
ssize_t cleanup_label;
__u32 nr_progs;
__u32 nr_maps;
int log_level;
int error;
struct ksym_relo_desc *relos;
int relo_cnt;
char attach_target[128];
int attach_kind;
};
void bpf_gen__init(struct bpf_gen *gen, int log_level);
int bpf_gen__finish(struct bpf_gen *gen);
void bpf_gen__free(struct bpf_gen *gen);
void bpf_gen__load_btf(struct bpf_gen *gen, const void *raw_data, __u32 raw_size);
void bpf_gen__map_create(struct bpf_gen *gen, struct bpf_create_map_attr *map_attr, int map_idx);
struct bpf_prog_load_params;
void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_attr, int prog_idx);
void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size);
void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx);
void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type);
void bpf_gen__record_extern(struct bpf_gen *gen, const char *name, int kind, int insn_idx);
#endif
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"
#define DBNAME "db.csv"
#define MAP_SIZE 64
#define MAX_LINE_LENGTH 255
/*
* Возвращает значение хэша ключа. Ключ это название страны.
*/
unsigned int hash(char *key) {
unsigned result = 0;
for (char *it = key; *it != '\0'; ++it) {
result += *it;
}
return result % MAP_SIZE;
}
/* Добавляет элемент к хэш таблице */
void map_add(COUNTRY **map, char *name, int population, int area) {
unsigned idx = hash(name);
COUNTRY **insertion_place = &map[idx];
COUNTRY *target = find(*insertion_place, name);
if (target == NULL) {
add(insertion_place, name, population, area);
} else {
target->population = population;
target->area = area;
}
}
/* Удаляет страну с указанным названием из хеш таблицы */
void map_delete(COUNTRY **map, char *name) {
unsigned idx = hash(name);
COUNTRY **target = &map[idx];
delete(target, *target);
}
/* Ищет страну с указанным названием в хеш таблице */
COUNTRY *map_find(COUNTRY **map, char *name) {
if (map == NULL) {
return NULL;
}
unsigned idx = hash(name);
COUNTRY *target = map[idx];
return target;
}
/* Печатает на экране все записи хеш таблицы */
void map_dump(COUNTRY **map) {
for (unsigned i = 0; i < MAP_SIZE; ++i) {
COUNTRY *it = map[i];
dump(it);
}
}
/* Создает хэш таблицу */
COUNTRY **map_create() {
COUNTRY **map = malloc(sizeof(COUNTRY *) * MAP_SIZE);
memset(map, 0, sizeof(COUNTRY *) * MAP_SIZE);
return map;
}
/* Удаляет хэш таблицу */
void map_clear(COUNTRY **map) {
int cnt;
for (cnt = 0; cnt < MAP_SIZE; cnt++)
clear(map[cnt]);
free(map);
}
/* Загружает таблицу из файла */
COUNTRY **map_load() {
char buf[MAX_LINE_LENGTH + 1];
char *par[3];
int cnt, pcount = 0;
COUNTRY *p, **map = NULL;
FILE *f = fopen(DBNAME, "r");
map = map_create();
buf[MAX_LINE_LENGTH] = 0x00;
if (f) {
while (fgets(buf, MAX_LINE_LENGTH, f)) {
pcount = 0;
par[pcount++] = buf;
cnt = 0;
while (buf[cnt]) {
if (buf[cnt] == ',') {
buf[cnt] = 0x00;
par[pcount++] = &buf[cnt + 1];
}
cnt++;
}
if (pcount == 3) {
map_add(map, par[0], atoi(par[1]), atoi(par[2]));
}
}
fclose(f);
}
return map;
}
/* Сохраняет таблицу в файл */
void map_save(COUNTRY **map) {
COUNTRY *p;
int cnt;
FILE *f = fopen(DBNAME, "w+");
if (f) {
for (cnt = 0; cnt < MAP_SIZE; cnt++) {
p = map[cnt];
while (p != NULL) {
fprintf(f, "%s,%d,%d\n", p->name, p->population, p->area);
p = p->next;
}
}
fclose(f);
}
}
|
#ifndef CFILE_H
#define CFILE_H
#include "common.h"
//STDIN_FILENO
//STDOUT_FILENO
//STDERR_FILENO
/*open mode:
r/rb O_RDONLY
w/wb creat a new file len = 0 or for write, O_WRONLY|O_CREAT|O_TRUNC
a/ab append O_WRONLY|O_CREAT|O_APPEND
r+/r+b/rb+ for read and write O_RDWR
w+/w+b/wb+ create a new file len = 0 or for read and write O_RDWR|O_CREAT|O_TRUNC
a+/a+b/ab+ append or create for read and write
*/
/*stdin/stdout/stderr*/
class Cfile
{
public:
Cfile(FILE* fp);
Cfile(const CHAR* fileName, const CHAR* type = "a+");
Cfile(const CHAR* fileName, const CHAR* type, FILE* fp);
Cfile(INT32 fd, const CHAR* type = "a+");
Cfile(VOID* buf, size_t size, const CHAR* type = "a+");/*for memory stream*/
Cfile();
~Cfile();
bool Cfopen(const CHAR* pathname, const CHAR* type = "a+");
bool Cfreopen(const CHAR* pathname, const CHAR* type, FILE* fp);
bool Cfdopen(INT32 fd, const CHAR* type = "a+");
bool Cfmemopen(VOID* buf, size_t size, const CHAR* type = "a+");
INT32 Cfwide(INT32 mode/*<0 ,byte, =0,noset, >0 Wide byte*/);
VOID Csetbuf(CHAR* buf/*buf size must be BUFSIZ*/);
INT32 Csetvbuf(CHAR* buf, INT32 mode/*_IOFBF/_IOLBF/_IONBF*/, size_t size/*buf size*/);
INT32 Cfflush();
bool isFileopenSuccess();
INT32 Cfclose();
INT32 Cfgetc();
INT32 Cferror();
INT32 Cfeof();
VOID Cclearerr();
INT32 Cungetc(INT32 c);
CHAR* Cfgets(CHAR* buf, INT32 n);
INT32 Cfputc(INT32 c);
INT32 Cfputs(const CHAR* str);
size_t Cfread(VOID* buf, size_t size, size_t nobj);
size_t Cfwrite(const VOID* buf, size_t size, size_t nobj);
LONG Cftell();
INT32 Cfseek(LONG offset, INT32 whence/*SEEK_SET SEEK_CUR SEEK_END*/);
VOID Crewind();
off_t Cftello();
off_t Cfseeko(off_t offset, INT32 whence/*SEEK_SET SEEK_CUR SEEK_END*/);
INT32 Cfgetpos(fpos_t* pos);
INT32 Cfsetpos(const fpos_t* pos);
FILE* getFILE();
INT32 getFILEno();
private:
FILE *file;
};
#endif
|
/* SPDX-License-Identifier: BSD-2-Clause-Patent
*
* SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md)
*
* This code is subject to the terms of the BSD+Patent license.
* See LICENSE file for more details.
*/
#ifndef _BEEROCKS_SOCKET_EVENT_LOOP_H_
#define _BEEROCKS_SOCKET_EVENT_LOOP_H_
#include "beerocks_event_loop.h"
#include "network/socket.h"
#include <memory>
#include <unordered_map>
namespace beerocks {
/**
* @brief ePoll based implementation of the EventLoop interface.
* @see EventLoop
*
* This class uses the Linux epoll APIs for monitoring the provided sockets for I/O operations.
* Timeout operations are achieved by using the timerfd mechanism, which delivers timer
* expiration notifications via a file descriptor.
*/
class SocketEventLoop : public EventLoop<std::shared_ptr<Socket>, std::chrono::milliseconds> {
public:
/**
* @brief Class constructor.
*
* Initializes an epoll file descriptor.
*
* @param [in] timeout Sets the master timeout (in milliseconds) for the event loop.
*/
explicit SocketEventLoop(TimeoutType timeout = TimeoutType::min());
/**
* @brief Class destructor.
*/
virtual ~SocketEventLoop();
/**
* @see EventPoll::add_event
*/
virtual bool add_event(EventType socket, EventHandlers handlers,
TimeoutType timeout = TimeoutType::min()) override;
/**
* @see EventPoll::del_event
*/
virtual bool del_event(EventType socket) override;
/**
* @brief Main event loop method.
* @see EventPoll::run
*
* Executes the epoll_wait() function and processes ocurred events.
*/
virtual int run() override;
private:
/**
* epoll file descriptor.
*/
int m_epoll_fd = -1;
/**
* Event loop master timeout (used for the epoll_wait function).
*/
TimeoutType m_timeout = TimeoutType::min();
/**
* @brief Data structure representing a socket added to the poll.
* This structure groups all the information required for processing socket events.
*/
struct EventData {
/**
* Socket event handler functions structure.
*/
EventHandlers handlers;
/**
* Shared pointer to the socket object.
*/
EventType socket = nullptr;
/**
* timer file descriptor.
*/
int timerfd = -1;
/**
* Socket timeout value in milliseconds.
*/
TimeoutType timeout_value = TimeoutType::min();
};
/**
* Map file descriptors to EventData structure instances.
*/
std::unordered_map<int, std::shared_ptr<EventData>> m_fd_to_event_data;
};
} // namespace beerocks
#endif // _BEEROCKS_SOCKET_EVENT_LOOP_H_
|
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
#define ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
#include <stdint.h>
#include <aaudio/AAudio.h>
#include "binding/IAAudioService.h"
#include "binding/AudioEndpointParcelable.h"
#include "binding/AAudioServiceInterface.h"
#include "client/IsochronousClockModel.h"
#include "client/AudioEndpoint.h"
#include "core/AudioStream.h"
#include "utility/AudioClock.h"
using android::sp;
using android::IAAudioService;
namespace aaudio {
// These are intended to be outside the range of what is normally encountered.
// TODO MAXes should probably be much bigger.
constexpr int32_t MIN_FRAMES_PER_BURST = 16; // arbitrary
constexpr int32_t MAX_FRAMES_PER_BURST = 16 * 1024; // arbitrary
constexpr int32_t MAX_BUFFER_CAPACITY_IN_FRAMES = 32 * 1024; // arbitrary
// A stream that talks to the AAudioService or directly to a HAL.
class AudioStreamInternal : public AudioStream {
public:
AudioStreamInternal(AAudioServiceInterface &serviceInterface, bool inService);
virtual ~AudioStreamInternal();
aaudio_result_t requestStart() override;
aaudio_result_t requestStop() override;
aaudio_result_t getTimestamp(clockid_t clockId,
int64_t *framePosition,
int64_t *timeNanoseconds) override;
virtual aaudio_result_t updateStateMachine() override;
aaudio_result_t open(const AudioStreamBuilder &builder) override;
aaudio_result_t release_l() override;
aaudio_result_t setBufferSize(int32_t requestedFrames) override;
int32_t getBufferSize() const override;
int32_t getBufferCapacity() const override;
int32_t getFramesPerBurst() const override;
int32_t getXRunCount() const override {
return mXRunCount;
}
aaudio_result_t registerThread() override;
aaudio_result_t unregisterThread() override;
aaudio_result_t joinThread(void** returnArg);
// Called internally from 'C'
virtual void *callbackLoop() = 0;
bool isMMap() override {
return true;
}
// Calculate timeout based on framesPerBurst
int64_t calculateReasonableTimeout();
aaudio_result_t startClient(const android::AudioClient& client,
const audio_attributes_t *attr,
audio_port_handle_t *clientHandle);
aaudio_result_t stopClient(audio_port_handle_t clientHandle);
aaudio_handle_t getServiceHandle() const {
return mServiceStreamHandle;
}
protected:
aaudio_result_t processData(void *buffer,
int32_t numFrames,
int64_t timeoutNanoseconds);
/**
* Low level data processing that will not block. It will just read or write as much as it can.
*
* It passed back a recommended time to wake up if wakeTimePtr is not NULL.
*
* @return the number of frames processed or a negative error code.
*/
virtual aaudio_result_t processDataNow(void *buffer,
int32_t numFrames,
int64_t currentTimeNanos,
int64_t *wakeTimePtr) = 0;
aaudio_result_t drainTimestampsFromService();
aaudio_result_t processCommands();
aaudio_result_t stopCallback();
virtual void advanceClientToMatchServerPosition() = 0;
virtual void onFlushFromServer() {}
aaudio_result_t onEventFromServer(AAudioServiceMessage *message);
aaudio_result_t onTimestampService(AAudioServiceMessage *message);
aaudio_result_t onTimestampHardware(AAudioServiceMessage *message);
void logTimestamp(AAudioServiceMessage &message);
// Calculate timeout for an operation involving framesPerOperation.
int64_t calculateReasonableTimeout(int32_t framesPerOperation);
int32_t getDeviceChannelCount() const { return mDeviceChannelCount; }
/**
* @return true if running in audio service, versus in app process
*/
bool isInService() const { return mInService; }
/**
* Is the service FIFO position currently controlled by the AAudio service or HAL,
* or set based on the Clock Model.
*
* @return true if the ClockModel is currently determining the FIFO position
*/
bool isClockModelInControl() const;
IsochronousClockModel mClockModel; // timing model for chasing the HAL
std::unique_ptr<AudioEndpoint> mAudioEndpoint; // source for reads or sink for writes
aaudio_handle_t mServiceStreamHandle; // opaque handle returned from service
int32_t mFramesPerBurst = MIN_FRAMES_PER_BURST; // frames per HAL transfer
int32_t mXRunCount = 0; // how many underrun events?
// Offset from underlying frame position.
int64_t mFramesOffsetFromService = 0; // offset for timestamps
std::unique_ptr<uint8_t[]> mCallbackBuffer;
int32_t mCallbackFrames = 0;
// The service uses this for SHARED mode.
bool mInService = false; // Is this running in the client or the service?
AAudioServiceInterface &mServiceInterface; // abstract interface to the service
SimpleDoubleBuffer<Timestamp> mAtomicInternalTimestamp;
AtomicRequestor mNeedCatchUp; // Ask read() or write() to sync on first timestamp.
float mStreamVolume = 1.0f;
int64_t mLastFramesWritten = 0;
int64_t mLastFramesRead = 0;
private:
/*
* Asynchronous write with data conversion.
* @param buffer
* @param numFrames
* @return fdrames written or negative error
*/
aaudio_result_t writeNowWithConversion(const void *buffer,
int32_t numFrames);
// Adjust timing model based on timestamp from service.
void processTimestamp(uint64_t position, int64_t time);
// Thread on other side of FIFO will have wakeup jitter.
// By delaying slightly we can avoid waking up before other side is ready.
const int32_t mWakeupDelayNanos; // delay past typical wakeup jitter
const int32_t mMinimumSleepNanos; // minimum sleep while polling
int32_t mTimeOffsetNanos = 0; // add to time part of an MMAP timestamp
AudioEndpointParcelable mEndPointParcelable; // description of the buffers filled by service
EndpointDescriptor mEndpointDescriptor; // buffer description with resolved addresses
int64_t mServiceLatencyNanos = 0;
// Sometimes the hardware is operating with a different channel count from the app.
// Then we require conversion in AAudio.
int32_t mDeviceChannelCount = 0;
int32_t mBufferSizeInFrames = 0; // local threshold to control latency
int32_t mBufferCapacityInFrames = 0;
};
} /* namespace aaudio */
#endif //ANDROID_AAUDIO_AUDIO_STREAM_INTERNAL_H
|
#ifndef TH_ENGINE_GUI_H
#define TH_ENGINE_GUI_H
#include "../core/engine.h"
#ifdef TH_WITH_RMLUI
namespace Rml
{
class Context;
class Element;
class ElementDocument;
class Decorator;
class DataModelConstructor;
class DataModelHandle;
class Event;
class EventListener;
class Variant;
}
#endif
namespace Tomahawk
{
namespace Engine
{
namespace GUI
{
#ifdef TH_WITH_RMLUI
class RenderSubsystem;
class FileSubsystem;
class MainSubsystem;
class ScopedContext;
class ContextInstancer;
class ListenerSubsystem;
class ListenerInstancer;
class DocumentSubsystem;
class DocumentInstancer;
class EventSubsystem;
class IEvent;
class DataModel;
class IElement;
class IElementDocument;
class DataNode;
class Listener;
class Context;
typedef std::function<std::string(const std::string&)> TranslationCallback;
typedef std::function<void(void*)> DestroyCallback;
typedef std::function<void(IEvent&)> EventCallback;
typedef std::function<void(IEvent&, const Core::VariantList&)> DataCallback;
typedef std::function<void(Core::Variant&)> GetterCallback;
typedef std::function<void(const Core::Variant&)> SetterCallback;
typedef std::function<void(Context*)> ModelCallback;
enum class ModalFlag
{
None,
Modal,
Keep
};
enum class FocusFlag
{
None,
Document,
Keep,
Auto
};
enum class Area
{
Margin = 0,
Border = 1,
Padding = 2,
Content = 3
};
enum class Display : uint8_t
{
None,
Block,
Inline,
InlineBlock,
Table,
TableRow,
TableRowGroup,
TableColumn,
TableColumnGroup,
TableCell
};
enum class Position : uint8_t
{
Static,
Relative,
Absolute,
Fixed
};
enum class Float : uint8_t
{
None,
Left,
Right
};
enum class TimingFunc
{
None,
Back,
Bounce,
Circular,
Cubic,
Elastic,
Exponential,
Linear,
Quadratic,
Quartic,
Quintic,
Sine,
Callback
};
enum class TimingDir
{
In = 1,
Out = 2,
InOut = 3
};
enum class EventPhase
{
None,
Capture = 1,
Target = 2,
Bubble = 4
};
enum class InputType
{
Keys = 1,
Scroll = 2,
Text = 3,
Cursor = 4,
Any = (Keys | Scroll | Text | Cursor)
};
inline InputType operator |(InputType A, InputType B)
{
return static_cast<InputType>(static_cast<uint64_t>(A) | static_cast<uint64_t>(B));
}
class TH_OUT IVariant
{
public:
static void Convert(Rml::Variant* From, Core::Variant* To);
static void Revert(Core::Variant* From, Rml::Variant* To);
static Compute::Vector4 ToColor4(const std::string& Value);
static std::string FromColor4(const Compute::Vector4& Base, bool HEX);
static Compute::Vector4 ToColor3(const std::string& Value);
static std::string FromColor3(const Compute::Vector4& Base, bool HEX);
static int GetVectorType(const std::string& Value);
static Compute::Vector4 ToVector4(const std::string& Base);
static std::string FromVector4(const Compute::Vector4& Base);
static Compute::Vector3 ToVector3(const std::string& Base);
static std::string FromVector3(const Compute::Vector3& Base);
static Compute::Vector2 ToVector2(const std::string& Base);
static std::string FromVector2(const Compute::Vector2& Base);
};
class TH_OUT IEvent
{
friend EventSubsystem;
friend DataModel;
private:
Rml::Event* Base;
public:
IEvent();
IEvent(Rml::Event* Ref);
EventPhase GetPhase() const;
void SetPhase(EventPhase Phase);
void SetCurrentElement(const IElement& Element);
IElement GetCurrentElement() const;
IElement GetTargetElement() const;
std::string GetType() const;
void StopPropagation();
void StopImmediatePropagation();
bool IsInterruptible() const;
bool IsPropagating() const;
bool IsImmediatePropagating() const;
bool GetBoolean(const std::string& Key) const;
int64_t GetInteger(const std::string& Key) const;
double GetNumber(const std::string& Key) const;
std::string GetString(const std::string& Key) const;
Compute::Vector2 GetVector2(const std::string& Key) const;
Compute::Vector3 GetVector3(const std::string& Key) const;
Compute::Vector4 GetVector4(const std::string& Key) const;
void* GetPointer(const std::string& Key) const;
Rml::Event* GetEvent() const;
bool IsValid() const;
};
class TH_OUT IElement
{
protected:
Rml::Element* Base;
public:
IElement();
IElement(Rml::Element* Ref);
virtual ~IElement() = default;
virtual void Release();
IElement Clone() const;
void SetClass(const std::string& ClassName, bool Activate);
bool IsClassSet(const std::string& ClassName) const;
void SetClassNames(const std::string& ClassNames);
std::string GetClassNames() const;
std::string GetAddress(bool IncludePseudoClasses = false, bool IncludeParents = true) const;
void SetOffset(const Compute::Vector2& Offset, const IElement& OffsetParent, bool OffsetFixed = false);
Compute::Vector2 GetRelativeOffset(Area Type = Area::Content);
Compute::Vector2 GetAbsoluteOffset(Area Type = Area::Content);
void SetClientArea(Area ClientArea);
Area GetClientArea() const;
void SetContentBox(const Compute::Vector2& ContentOffset, const Compute::Vector2& ContentBox);
float GetBaseline() const;
bool GetIntrinsicDimensions(Compute::Vector2& Dimensions, float& Ratio);
bool IsPointWithinElement(const Compute::Vector2& Point);
bool IsVisible() const;
float GetZIndex() const;
bool SetProperty(const std::string& Name, const std::string& Value);
void RemoveProperty(const std::string& Name);
std::string GetProperty(const std::string& Name);
std::string GetLocalProperty(const std::string& Name);
float ResolveNumericProperty(const std::string& PropertyName);
Compute::Vector2 GetContainingBlock();
Position GetPosition();
Float GetFloat();
Display GetDisplay();
float GetLineHeight();
bool Project(Compute::Vector2& Point) const noexcept;
bool Animate(const std::string& PropertyName, const std::string& TargetValue, float Duration, TimingFunc Func, TimingDir Dir, int NumIterations = 1, bool AlternateDirection = true, float Delay = 0.0f);
bool AddAnimationKey(const std::string& PropertyName, const std::string& TargetValue, float Duration, TimingFunc Func, TimingDir Dir);
void SetPseudoClass(const std::string& PseudoClass, bool Activate);
bool IsPseudoClassSet(const std::string& PseudoClass) const;
void SetAttribute(const std::string& Name, const std::string& Value);
std::string GetAttribute(const std::string& Name);
bool HasAttribute(const std::string& Name) const;
void RemoveAttribute(const std::string& Name);
IElement GetFocusLeafNode();
std::string GetTagName() const;
std::string GetId() const;
void SetId(const std::string& Id);
float GetAbsoluteLeft();
float GetAbsoluteTop();
float GetClientLeft();
float GetClientTop();
float GetClientWidth();
float GetClientHeight();
IElement GetOffsetParent();
float GetOffsetLeft();
float GetOffsetTop();
float GetOffsetWidth();
float GetOffsetHeight();
float GetScrollLeft();
void SetScrollLeft(float ScrollLeft);
float GetScrollTop();
void SetScrollTop(float ScrollTop);
float GetScrollWidth();
float GetScrollHeight();
IElementDocument GetOwnerDocument() const;
IElement GetParentNode() const;
IElement GetNextSibling() const;
IElement GetPreviousSibling() const;
IElement GetFirstChild() const;
IElement GetLastChild() const;
IElement GetChild(int Index) const;
int GetNumChildren(bool IncludeNonDOMElements = false) const;
void GetInnerHTML(std::string& Content) const;
std::string GetInnerHTML() const;
void SetInnerHTML(const std::string& HTML);
bool IsFocused();
bool IsHovered();
bool IsActive();
bool IsChecked();
bool Focus();
void Blur();
void Click();
void AddEventListener(const std::string& Event, Listener* Source, bool InCapturePhase = false);
void RemoveEventListener(const std::string& Event, Listener* Source, bool InCapturePhase = false);
bool DispatchEvent(const std::string& Type, const Core::VariantArgs& Args);
void ScrollIntoView(bool AlignWithTop = true);
IElement AppendChild(const IElement& Element, bool DOMElement = true);
IElement InsertBefore(const IElement& Element, const IElement& AdjacentElement);
IElement ReplaceChild(const IElement& InsertedElement, const IElement& ReplacedElement);
IElement RemoveChild(const IElement& Element);
bool HasChildNodes() const;
IElement GetElementById(const std::string& Id);
IElement QuerySelector(const std::string& Selector);
std::vector<IElement> QuerySelectorAll(const std::string& Selectors);
int GetClippingIgnoreDepth();
bool IsClippingEnabled();
bool CastFormColor(Compute::Vector4* Ptr, bool Alpha);
bool CastFormString(std::string* Ptr);
bool CastFormPointer(void** Ptr);
bool CastFormInt32(int32_t* Ptr);
bool CastFormUInt32(uint32_t* Ptr);
bool CastFormFlag32(uint32_t* Ptr, uint32_t Mask);
bool CastFormInt64(int64_t* Ptr);
bool CastFormUInt64(uint64_t* Ptr);
bool CastFormFlag64(uint64_t* Ptr, uint64_t Mask);
bool CastFormFloat(float* Ptr);
bool CastFormFloat(float* Ptr, float Mult);
bool CastFormDouble(double* Ptr);
bool CastFormBoolean(bool* Ptr);
std::string GetFormName() const;
void SetFormName(const std::string& Name);
std::string GetFormValue() const;
void SetFormValue(const std::string& Value);
bool IsFormDisabled() const;
void SetFormDisabled(bool Disable);
Rml::Element* GetElement() const;
bool IsValid() const;
public:
static std::string FromPointer(void* Ptr);
static void* ToPointer(const std::string& Value);
};
class TH_OUT IElementDocument : public IElement
{
public:
IElementDocument();
IElementDocument(Rml::ElementDocument* Ref);
virtual ~IElementDocument() = default;
virtual void Release() override;
void SetTitle(const std::string& Title);
void PullToFront();
void PushToBack();
void Show(ModalFlag Modal = ModalFlag::None, FocusFlag Focus = FocusFlag::Auto);
void Hide();
void Close();
std::string GetTitle() const;
std::string GetSourceURL() const;
IElement CreateElement(const std::string& Name);
bool IsModal() const;
Rml::ElementDocument* GetElementDocument() const;
};
class TH_OUT Subsystem
{
friend RenderSubsystem;
friend DocumentSubsystem;
friend ListenerSubsystem;
friend Context;
private:
static Script::VMManager* ScriptInterface;
static ContextInstancer* ContextFactory;
static DocumentInstancer* DocumentFactory;
static ListenerInstancer* ListenerFactory;
static RenderSubsystem* RenderInterface;
static FileSubsystem* FileInterface;
static MainSubsystem* SystemInterface;
static uint64_t Id;
static bool HasDecorators;
static int State;
public:
static bool Create();
static bool Release();
static void SetMetadata(Graphics::Activity* Activity, ContentManager* Content, Core::Timer* Time);
static void SetTranslator(const std::string& Name, const TranslationCallback& Callback);
static void SetManager(Script::VMManager* Manager);
static RenderSubsystem* GetRenderInterface();
static FileSubsystem* GetFileInterface();
static MainSubsystem* GetSystemInterface();
static Graphics::GraphicsDevice* GetDevice();
static Graphics::Texture2D* GetBackground();
static Compute::Matrix4x4* GetTransform();
static Compute::Matrix4x4* GetProjection();
static Compute::Matrix4x4 ToMatrix(const void* Matrix);
static std::string EscapeHTML(const std::string& Text);
private:
static void ResizeDecorators(int Width, int Height);
static void CreateDecorators(Graphics::GraphicsDevice* Device);
static void ReleaseDecorators();
static void CreateElements();
static void ReleaseElements();
};
class TH_OUT DataModel : public Core::Object
{
friend Context;
private:
std::unordered_map<std::string, DataNode*> Props;
std::vector<std::function<void()>> Callbacks;
Rml::DataModelConstructor* Base;
ModelCallback OnUnmount;
private:
DataModel(Rml::DataModelConstructor* Ref);
public:
virtual ~DataModel() override;
DataNode* SetProperty(const std::string& Name, const Core::Variant& Value);
DataNode* SetProperty(const std::string& Name, Core::Variant* Reference);
DataNode* SetArray(const std::string& Name);
DataNode* SetString(const std::string& Name, const std::string& Value);
DataNode* SetInteger(const std::string& Name, int64_t Value);
DataNode* SetFloat(const std::string& Name, float Value);
DataNode* SetDouble(const std::string& Name, double Value);
DataNode* SetBoolean(const std::string& Name, bool Value);
DataNode* SetPointer(const std::string& Name, void* Value);
DataNode* GetProperty(const std::string& Name);
std::string GetString(const std::string& Name);
int64_t GetInteger(const std::string& Name);
float GetFloat(const std::string& Name);
double GetDouble(const std::string& Name);
bool GetBoolean(const std::string& Name);
void* GetPointer(const std::string& Name);
bool SetCallback(const std::string& Name, const DataCallback& Callback);
bool SetUnmountCallback(const ModelCallback& Callback);
bool HasChanged(const std::string& VariableName) const;
void SetDetachCallback(std::function<void()>&& Callback);
void Change(const std::string& VariableName);
void Detach();
bool IsValid() const;
Rml::DataModelConstructor* Get();
};
class TH_OUT DataNode
{
friend Context;
friend DataModel;
private:
std::vector<DataNode> Childs;
std::string Name;
Core::Variant* Ref;
DataModel* Handle;
void* Order;
size_t Depth;
bool Safe;
private:
DataNode(DataModel* Model, const std::string& TopName, const Core::Variant& Initial) noexcept;
DataNode(DataModel* Model, const std::string& TopName, Core::Variant* Reference) noexcept;
public:
DataNode(DataNode&& Other) noexcept;
DataNode(const DataNode& Other) noexcept;
~DataNode();
DataNode& Insert(size_t Where, const Core::VariantList& Initial, std::pair<void*, size_t>* Top = nullptr);
DataNode& Insert(size_t Where, const Core::Variant& Initial, std::pair<void*, size_t>* Top = nullptr);
DataNode& Insert(size_t Where, Core::Variant* Reference, std::pair<void*, size_t>* Top = nullptr);
DataNode& Add(const Core::VariantList& Initial, std::pair<void*, size_t>* Top = nullptr);
DataNode& Add(const Core::Variant& Initial, std::pair<void*, size_t>* Top = nullptr);
DataNode& Add(Core::Variant* Reference, std::pair<void*, size_t>* Top = nullptr);
DataNode& At(size_t Index);
bool Remove(size_t Index);
bool Clear();
void SortTree();
void Replace(const Core::VariantList& Data, std::pair<void*, size_t>* Top = nullptr);
void Set(const Core::Variant& NewValue);
void Set(Core::Variant* NewReference);
void SetTop(void* SeqId, size_t Depth);
void SetString(const std::string& Value);
void SetVector2(const Compute::Vector2& Value);
void SetVector3(const Compute::Vector3& Value);
void SetVector4(const Compute::Vector4& Value);
void SetInteger(int64_t Value);
void SetFloat(float Value);
void SetDouble(double Value);
void SetBoolean(bool Value);
void SetPointer(void* Value);
size_t GetSize() const;
void* GetSeqId() const;
size_t GetDepth() const;
const Core::Variant& Get();
std::string GetString();
Compute::Vector2 GetVector2();
Compute::Vector3 GetVector3();
Compute::Vector4 GetVector4();
int64_t GetInteger();
float GetFloat();
double GetDouble();
bool GetBoolean();
void* GetPointer();
DataNode& operator= (const DataNode& Other) noexcept;
DataNode& operator= (DataNode&& Other) noexcept;
private:
void GetValue(Rml::Variant& Result);
void SetValue(const Rml::Variant& Result);
void SetValueStr(const std::string& Value);
void SetValueNum(double Value);
void SetValueInt(int64_t Value);
int64_t GetValueSize();
};
class TH_OUT Listener : public Core::Object
{
friend IElement;
friend Context;
private:
Rml::EventListener* Base;
public:
Listener(const EventCallback& NewCallback);
Listener(const std::string& FunctionName);
virtual ~Listener() override;
};
class TH_OUT Context : public Core::Object
{
friend DocumentSubsystem;
friend ListenerSubsystem;
private:
struct
{
bool Keys = false;
bool Scroll = false;
bool Text = false;
bool Cursor = false;
} Inputs;
private:
std::unordered_map<int, std::unordered_map<std::string, Rml::Element*>> Elements;
std::unordered_map<std::string, DataModel*> Models;
Script::VMCompiler* Compiler;
Compute::Vector2 Cursor;
ModelCallback OnMount;
ScopedContext* Base;
bool Loading;
public:
Context(const Compute::Vector2& Size);
Context(Graphics::GraphicsDevice* Device);
virtual ~Context() override;
void EmitKey(Graphics::KeyCode Key, Graphics::KeyMod Mod, int Virtual, int Repeat, bool Pressed);
void EmitInput(const char* Buffer, int Length);
void EmitWheel(int X, int Y, bool Normal, Graphics::KeyMod Mod);
void EmitResize(int Width, int Height);
void UpdateEvents(Graphics::Activity* Activity);
void RenderLists(Graphics::Texture2D* Target);
void ClearCache();
IElementDocument Construct(const std::string& Path);
bool Deconstruct();
bool Inject(const std::string& ConfPath);
bool AddFontFace(const std::string& Path, bool UseAsFallback = false);
bool IsLoading();
bool IsInputFocused();
bool WasInputUsed(uint32_t InputTypeMask);
const std::unordered_map<std::string, bool>& GetFontFaces();
Rml::Context* GetContext();
Compute::Vector2 GetDimensions() const;
void SetDensityIndependentPixelRatio(float DensityIndependentPixelRatio);
float GetDensityIndependentPixelRatio() const;
IElementDocument CreateDocument(const std::string& InstancerName = "body");
void EnableMouseCursor(bool Enable);
IElementDocument GetDocument(const std::string& Id);
IElementDocument GetDocument(int Index);
int GetNumDocuments() const;
IElement GetElementById(int DocIndex, const std::string& Id);
IElement GetHoverElement();
IElement GetFocusElement();
IElement GetRootElement();
IElement GetElementAtPoint(const Compute::Vector2& Point, const IElement& IgnoreElement = nullptr, const IElement& Element = nullptr) const;
void PullDocumentToFront(const IElementDocument& Document);
void PushDocumentToBack(const IElementDocument& Document);
void UnfocusDocument(const IElementDocument& Document);
void AddEventListener(const std::string& Event, Listener* Listener, bool InCapturePhase = false);
void RemoveEventListener(const std::string& Event, Listener* Listener, bool InCapturePhase = false);
bool IsMouseInteracting() const;
bool GetActiveClipRegion(Compute::Vector2& Origin, Compute::Vector2& Dimensions) const;
void SetActiveClipRegion(const Compute::Vector2& Origin, const Compute::Vector2& Dimensions);
DataModel* SetDataModel(const std::string& Name);
DataModel* GetDataModel(const std::string& Name);
bool RemoveDataModel(const std::string& Name);
bool RemoveDataModels();
void SetDocumentsBaseTag(const std::string& Tag);
void SetMountCallback(const ModelCallback& Callback);
const std::string& GetDocumentsBaseTag();
private:
bool Inject(Core::Document* Conf, const std::string& Relative);
bool Preprocess(const std::string& Path, std::string& Buffer);
void Decompose(std::string& Buffer);
void CreateVM();
void ClearVM();
private:
static int GetKeyCode(Graphics::KeyCode Key);
static int GetKeyMod(Graphics::KeyMod Mod);
};
#endif
}
}
}
#endif
|
--- content/browser/renderer_host/render_process_host_impl.h.orig 2020-03-16 18:40:31 UTC
+++ content/browser/renderer_host/render_process_host_impl.h
@@ -458,10 +458,10 @@ class CONTENT_EXPORT RenderProcessHostImpl
is_for_guests_only_ = is_for_guests_only;
}
-#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
+#if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX) && !defined(OS_BSD)
// Launch the zygote early in the browser startup.
static void EarlyZygoteLaunch();
-#endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
+#endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX) && !defined(OS_BSD)
// Called when a video capture stream or an audio stream is added or removed
// and used to determine if the process should be backgrounded or not.
|
/******************************************************************************
* Automated Trading System *
* *
* Copyright (C) 2017 Xiaojun Gao *
* *
* Distributed under the terms and conditions of the MIT License. *
******************************************************************************/
#ifndef __EVENT_QUEUE_H__
#define __EVENT_QUEUE_H__
#include "mpscq.h"
#include "spscq.h"
#include "mem.h"
#include "event.h"
typedef enum {
CATEGORY_MARKET = 0,
CATEGORY_EXECUTION,
CATEGORY_SERVICE,
CATEGORY_COMMAND,
CATEGORY_LAST
}queue_category;
typedef struct event_queue_s event_queue_t;
struct event_queue_s {
atomic_t refcount;
void *data;
/* private */
spscq_t spsc;
/* only access by consumer */
void *ctx;
queue_category category;
/* mpsc */
mpscq_node mpsc_node;
/* min heap node */
void *heap_node[3];
uint64_t start_id;
};
EXTERN event_queue_t* event_queue_new(size_t size, queue_category category);
FUNC event_queue_t *event_queue_init(event_queue_t *q, unsigned int size,
queue_category category);
FUNC void event_queue_destroy(event_queue_t *q);
FUNC void event_queue_ref(event_queue_t *q);
FUNC void event_queue_unref(event_queue_t *q);
FUNC unsigned int event_queue_size(event_queue_t *q);
FUNC unsigned int event_queue_capacity(event_queue_t *q);
EXTERN int event_queue_push(event_queue_t *q, void *e);
FUNC void *event_queue_peek(const event_queue_t *q);
FUNC void *event_queue_pop(event_queue_t *q);
FUNC int event_queue_is_empty(event_queue_t *q);
FUNC int event_queue_is_full(event_queue_t *q);
#endif // __EVENT_QUEUE_H__
|
//
// Created by Can on 9/2/15.
//
#ifndef TECOLOR_SPECTRALKIT_H
#define TECOLOR_SPECTRALKIT_H
#include "Illuminant.h"
#include "ColorMatchingFunction.h"
#include "Tristimulus.h"
#include "ReflectanceSet.h"
namespace tecolor {
Tristimulus Refl2XYZ(const Illuminant &ill, const ColorMatchingFunction &cmf, const SpectraMatrix &refl);
Primaries Rad2Yxy(const Illuminant &ill, const ColorMatchingFunction &cmf);
Primaries Rad2xy(const Illuminant &ill, const ColorMatchingFunction &cmf);
}
#endif //TECOLOR_SPECTRALKIT_H
|
#ifndef LINKED_LIST_NODE_H
#define LINKED_LIST_NODE_H
#include <cstring>
using namespace std;
class linkedListNode
{
public:
char *place;
int index;
linkedListNode* next;
linkedListNode(char *p, int i)
{
place = new char[strlen(p)+1];
strcpy(place,p);
index = i;
next=NULL;
}
~linkedListNode()
{
if(next!=NULL)
{
delete next;
next = NULL;
}
delete [] place;
}
};
#endif // LINKED_LIST_H
|
#ifndef __SORT_STABLE_QUICK_SORT_H_
#define __SORT_STABLE_QUICK_SORT_H_
#include <tgstk_comms.h>
#include <sorts/sort_comms.h>
class SortStableQuickObject : public SortObject
{
public:
TGSTK_EXPORT SortStableQuickObject(SortVTable & vTable);
private:
int _sort(void * objs, int elemSize, int size, SortType type, int begin, int end, void * tempObj);
private:
static int on_sort_list_iterate(void * element, void * arg);
protected:
int onSort(void * objs, int elemSize, int size, SortType type);
};
#endif
|
#ifndef _IOTHUBDEVICE_H
#define _IOTHUBDEVICE_H
#include <string>
#include <map>
#include "IoTHubMessage.h"
#include <AzureIoTHub.h>
#include "azure_c_shared_utility/doublylinkedlist.h"
class IoTHubDevice
{
public:
typedef IOTHUBMESSAGE_DISPOSITION_RESULT (*MessageCallback)(IoTHubDevice &iotHubDevice, IoTHubMessage &iotHubMessage, void *userContext);
typedef void (*EventConfirmationCallback)(IoTHubDevice &iotHubDevice, IOTHUB_CLIENT_CONFIRMATION_RESULT result, void *userContext);
typedef void (*ConnectionStatusCallback)(IoTHubDevice &iotHubDevice, IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void *userContext);
typedef int (*DeviceMethodCallback)(IoTHubDevice &iotHubDevice, const unsigned char *payload, size_t size, unsigned char** response, size_t* resp_size, void* userContext);
typedef int (*UnknownDeviceMethodCallback)(IoTHubDevice &iotHubDevice, const char *methodName, const unsigned char *payload, size_t size, unsigned char** response, size_t* resp_size, void* userContext);
typedef void(*DeviceTwinCallback)(DEVICE_TWIN_UPDATE_STATE update_state, const char* payLoad, void* userContext);
typedef void(*ReportedStateCallback)(IoTHubDevice &iotHubDevice, int status_code, void* userContext);
private:
struct MessageUserContext
{
DLIST_ENTRY dlistEntry;
IoTHubDevice *iotHubDevice;
EventConfirmationCallback eventConfirmationCallback;
void *userContext;
MessageUserContext(IoTHubDevice *iotHubDevice, EventConfirmationCallback eventConfirmationCallback, void *userContext) :
iotHubDevice(iotHubDevice), eventConfirmationCallback(eventConfirmationCallback), userContext(userContext)
{
dlistEntry = { 0 };
}
};
struct ReportedStateUserContext
{
DLIST_ENTRY dlistEntry;
IoTHubDevice *iotHubDevice;
ReportedStateCallback reportedStateCallback;
void *userContext;
ReportedStateUserContext(IoTHubDevice *iotHubDevice, ReportedStateCallback reportedStateCallback, void *userContext) :
iotHubDevice(iotHubDevice), reportedStateCallback(reportedStateCallback), userContext(userContext)
{
dlistEntry = { 0 };
}
};
struct DeviceMethodUserContext
{
DeviceMethodCallback deviceMethodCallback;
void *userContext;
DeviceMethodUserContext(DeviceMethodCallback deviceMethodCallback, void *userContext) :
deviceMethodCallback(deviceMethodCallback), userContext(userContext)
{
}
};
IOTHUB_CLIENT_LL_HANDLE _deviceHandle;
bool _logging;
const char *_certificate;
int _startResult;
MessageCallback _messageCallback;
ConnectionStatusCallback _connectionStatusCallback;
UnknownDeviceMethodCallback _unknownDeviceMethodCallback;
DeviceTwinCallback _deviceTwinCallback;
void *_messageCallbackUC;
void *_connectionStatusCallbackUC;
void *_unknownDeviceMethodCallbackUC;
void *_deviceTwinCallbackUC;
DLIST_ENTRY _outstandingEventList;
DLIST_ENTRY _outstandingReportedStateEventList;
std::map<std::string, DeviceMethodUserContext *> _deviceMethods;
MapUtil *_parsedCS;
public:
enum Protocol
{
MQTT,
};
IoTHubDevice(const char *connectionString, IoTHubDevice::Protocol protocol = IoTHubDevice::Protocol::MQTT);
IoTHubDevice(const char *connectionString,
const char *x509Certificate,
const char *x509PrivateKey,
IoTHubDevice::Protocol protocol = IoTHubDevice::Protocol::MQTT);
~IoTHubDevice();
int Start();
void Stop();
const char *GetHostName();
const char *GetDeviceId();
const char *GetVersion();
MessageCallback SetMessageCallback(MessageCallback messageCallback, void *userContext = NULL);
ConnectionStatusCallback SetConnectionStatusCallback(ConnectionStatusCallback ConnectionStatusCallback, void *userContext = NULL);
DeviceMethodCallback SetDeviceMethodCallback(const char *methodName, DeviceMethodCallback deviceMethodCallback, void *userContext = NULL);
UnknownDeviceMethodCallback SetUnknownDeviceMethodCallback(UnknownDeviceMethodCallback unknownDeviceMethodCallback, void *userContext = NULL);
DeviceTwinCallback SetDeviceTwinCallback(DeviceTwinCallback deviceTwinCallback, void *userContext = NULL);
IOTHUB_CLIENT_LL_HANDLE GetHandle() const;
bool WaitingEvents() { return !DList_IsListEmpty(&_outstandingEventList); }
int WaitingEventsCount();
bool GetLogging() { return _logging; }
void SetLogging(bool value);
const char *GetTrustedCertificate() { return _certificate; }
void SetTrustedCertificate(const char *value);
IOTHUB_CLIENT_STATUS GetSendStatus();
IOTHUB_CLIENT_RESULT SendEventAsync(const std::string &message, EventConfirmationCallback eventConfirmationCallback, void *userContext = NULL);
IOTHUB_CLIENT_RESULT SendEventAsync(const char *message, EventConfirmationCallback eventConfirmationCallback, void *userContext = NULL);
IOTHUB_CLIENT_RESULT SendEventAsync(const uint8_t *message, size_t length, EventConfirmationCallback eventConfirmationCallback, void *userContext = NULL);
IOTHUB_CLIENT_RESULT SendEventAsync(const IoTHubMessage *message, EventConfirmationCallback eventConfirmationCallback, void *userContext = NULL);
IOTHUB_CLIENT_RESULT SendReportedState(const char* reportedState, ReportedStateCallback reportedStateCallback, void* userContext = NULL);
void DoWork();
private:
const char *_connectionString;
const char *_x509Certificate;
const char *_x509PrivateKey;
IoTHubDevice::Protocol _protocol;
// Cloud to device messages
static IOTHUBMESSAGE_DISPOSITION_RESULT InternalMessageCallback(IOTHUB_MESSAGE_HANDLE message, void *userContext);
// Reported status_code
static void InternalReportedStateCallback(int status_code, void* userContextCallback);
// Connection status callback
static void InternalConnectionStatusCallback(IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void* userContext);
// Event confirmation callback (for each message sent)
static void InternalEventConfirmationCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void *userContext);
// Device method callback
static int InternalDeviceMethodCallback(const char *methodName, const unsigned char *payload, size_t size, unsigned char **response, size_t *responseSize, void *userContext);
// Device twin callback
static void InternalDeviceTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char* payLoad, size_t size, void* userContextCallback);
static IOTHUB_CLIENT_TRANSPORT_PROVIDER GetProtocol(IoTHubDevice::Protocol protocol);
};
#endif // _IOTHUBDEVICE_H
|
#ifdef NS3_MODULE_COMPILATION
# error "Do not include ns3 module aggregator headers from other modules; these are meant only for end user scripts."
#endif
#ifndef NS3_MODULE_CSMA_LAYOUT
// Module headers:
#include "csma-star-helper.h"
#endif
|
// Animation names
#define CYBORG_ANIM_DEFAULT_ANIMATION 0
#define CYBORG_ANIM_ATTACKCLOSE01 1
#define CYBORG_ANIM_ATTACKCLOSE02 2
#define CYBORG_ANIM_DEATH01 3
#define CYBORG_ANIM_DEATH02 4
#define CYBORG_ANIM_DEATHREST 5
#define CYBORG_ANIM_DEATHTWIST 6
#define CYBORG_ANIM_TOFIRE 7
#define CYBORG_ANIM_FIRE01 8
#define CYBORG_ANIM_FIRE02 9
#define CYBORG_ANIM_FIRE01SLIDE 10
#define CYBORG_ANIM_FIRE02SLIDE 11
#define CYBORG_ANIM_FROMFIRE 12
#define CYBORG_ANIM_WAIT01 13
#define CYBORG_ANIM_WAIT02 14
#define CYBORG_ANIM_WAIT03 15
#define CYBORG_ANIM_WALK01 16
#define CYBORG_ANIM_WALK02 17
#define CYBORG_ANIM_WOUND01 18
#define CYBORG_ANIM_WOUND02 19
#define CYBORG_ANIM_WOUND03 20
#define CYBORG_ANIM_WOUND04 21
// Color names
// Patch names
// Names of collision boxes
#define CYBORG_COLLISION_BOX_PART_NAME 0
// Attaching position names
// Sound names
|
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
enum {
ST_PATH=1,
ST_RCV,
ST_OUTPUT,
ST_ERR,
ST_Ex,
ST_T
};
struct tftp_client_fsa_st {
int state;
char *path;
struct msg_c2s_st sbuf;
struct msg_s2c_st rbuf;
int msgid;
int outfd;
char *errstr;
};
static void tftp_fsa_driver(struct tftp_client_fsa_st *fsa)
{
switch (fsa->state) {
case ST_PATH:
fsa->sbuf.xxx
fsa->sbuf.xxx
fsa->sbuf.xxx
if (msgsnd(fsa->msgid, &fsa->sbuf, sizeof(fsa->sbuf)-sizeof(long), 0)) {
}
}
}
|
/**
*
* @file ctile.c
*
* PLASMA auxiliary routines
* PLASMA is a software package provided by Univ. of Tennessee,
* Univ. of California Berkeley and Univ. of Colorado Denver
*
* @version 2.6.0
* @author Jakub Kurzak
* @author Mathieu Faverge
* @date 2010-11-15
* @generated c Tue Jan 7 11:45:15 2014
*
**/
#include "common.h"
#include "auxiliary.h"
#include "tile.h"
/***************************************************************************//**
*
* @ingroup PLASMA_Complex32_t
*
* PLASMA_cLapack_to_Tile - Conversion from LAPACK layout to tile layout.
*
*******************************************************************************
*
* @param[in] Af77
* LAPACK matrix.
*
* @param[in] LDA
* The leading dimension of the matrix Af77.
*
* @param[in,out] A
* Descriptor of the PLASMA matrix in tile layout.
* If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE,
* A->mat is not used and set to Af77 when returns, else if
* PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE,
* A->mat has to be allocated before.
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
*
*******************************************************************************
*
* @sa PLASMA_cLapack_to_Tile_Async
* @sa PLASMA_cTile_to_Lapack
* @sa PLASMA_cLapack_to_Tile
* @sa PLASMA_dLapack_to_Tile
* @sa PLASMA_sLapack_to_Tile
*
******************************************************************************/
int PLASMA_cLapack_to_Tile(PLASMA_Complex32_t *Af77, int LDA, PLASMA_desc *A)
{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request;
int status;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cLapack_to_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_cLapack_to_Tile", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_sequence_create(plasma, &sequence);
plasma_parallel_call_5(
plasma_pclapack_to_tile,
PLASMA_Complex32_t*, Af77,
int, LDA,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, &request);
plasma_dynamic_sync();
status = sequence->status;
plasma_sequence_destroy(plasma, sequence);
return status;
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex32_t_Tile_Async
*
* PLASMA_cLapack_to_Tile_Async - Conversion from LAPACK layout to tile layout.
* Non-blocking equivalent of PLASMA_cLapack_to_Tile().
* May return before the computation is finished.
* Allows for pipelining of operations ar runtime.
*
*
*******************************************************************************
*
* @param[in] Af77
* LAPACK matrix.
*
* @param[in] LDA
* The leading dimension of the matrix Af77.
*
* @param[in,out] A
* Descriptor of the PLASMA matrix in tile layout.
* If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE,
* A->mat is not used and set to Af77 when returns, else if
* PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE,
* A->mat has to be allocated before.
*
* @param[in] sequence
* Identifies the sequence of function calls that this call belongs to
* (for completion checks and exception handling purposes).
*
* @param[out] request
* Identifies this function call (for exception handling purposes).
*
*******************************************************************************
*
* @sa PLASMA_cTile_to_Lapack_Async
* @sa PLASMA_cLapack_to_Tile
* @sa PLASMA_cLapack_to_Tile_Async
* @sa PLASMA_dLapack_to_Tile_Async
* @sa PLASMA_sLapack_to_Tile_Async
*
******************************************************************************/
int PLASMA_cLapack_to_Tile_Async(PLASMA_Complex32_t *Af77, int LDA, PLASMA_desc *A,
PLASMA_sequence *sequence, PLASMA_request *request)
{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cLapack_to_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_cLapack_to_Tile", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_parallel_call_5(
plasma_pclapack_to_tile,
PLASMA_Complex32_t*, Af77,
int, LDA,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex32_t
*
* PLASMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout.
*
*******************************************************************************
*
* @param[in] A
* Descriptor of the PLASMA matrix in tile layout.
*
* @param[in,out] Af77
* LAPACK matrix.
* If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE,
* Af77 has to be A->mat, else if
* PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE,
* Af77 has to be allocated before.
*
* @param[in] LDA
* The leading dimension of the matrix Af77.
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
*
*******************************************************************************
*
* @sa PLASMA_cTile_to_Lapack_Async
* @sa PLASMA_cLapack_to_Tile
* @sa PLASMA_cTile_to_Lapack
* @sa PLASMA_dTile_to_Lapack
* @sa PLASMA_sTile_to_Lapack
*
******************************************************************************/
int PLASMA_cTile_to_Lapack(PLASMA_desc *A, PLASMA_Complex32_t *Af77, int LDA)
{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
PLASMA_sequence *sequence = NULL;
PLASMA_request request;
int status;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cTile_to_Lapack", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_cTile_to_Lapack", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_sequence_create(plasma, &sequence);
plasma_static_call_5(
plasma_pctile_to_lapack,
PLASMA_desc, descA,
PLASMA_Complex32_t*, Af77,
int, LDA,
PLASMA_sequence*, sequence,
PLASMA_request*, &request);
plasma_dynamic_sync();
status = sequence->status;
plasma_sequence_destroy(plasma, sequence);
return status;
}
/***************************************************************************//**
*
* @ingroup PLASMA_Complex32_t_Tile_Async
*
* PLASMA_cTile_to_Lapack_Async - Conversion from LAPACK layout to tile layout.
* Non-blocking equivalent of PLASMA_cTile_to_Lapack().
* May return before the computation is finished.
* Allows for pipelining of operations ar runtime.
*
*
*******************************************************************************
*
* @param[in] A
* Descriptor of the PLASMA matrix in tile layout.
*
* @param[in,out] Af77
* LAPACK matrix.
* If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE,
* Af77 has to be A->mat, else if
* PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE,
* Af77 has to be allocated before.
*
* @param[in] LDA
* The leading dimension of the matrix Af77.
*
* @param[in] sequence
* Identifies the sequence of function calls that this call belongs to
* (for completion checks and exception handling purposes).
*
* @param[out] request
* Identifies this function call (for exception handling purposes).
*
*******************************************************************************
*
* @sa PLASMA_cLapack_to_Tile_Async
* @sa PLASMA_cTile_to_Lapack
* @sa PLASMA_cTile_to_Lapack_Async
* @sa PLASMA_dTile_to_Lapack_Async
* @sa PLASMA_sTile_to_Lapack_Async
*
******************************************************************************/
int PLASMA_cTile_to_Lapack_Async(PLASMA_desc *A, PLASMA_Complex32_t *Af77, int LDA,
PLASMA_sequence *sequence, PLASMA_request *request)
{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cTile_to_Lapack", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_cTile_to_Lapack", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_static_call_5(
plasma_pctile_to_lapack,
PLASMA_desc, descA,
PLASMA_Complex32_t*, Af77,
int, LDA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}
|
#pragma once
#include <stdint.h>
// TODO: RFC6962 defines the empty list hash as sha256(b''); while we're using 0 here. Should we
// change?
/*
Implementation of Merkle proof verification. Follows RFC 6962:
https://www.rfc-editor.org/rfc/pdfrfc/rfc6962.txt.pdf, using SHA256 as the hash function.
Namely (||| denodes concatenation):
- leaf hashes for an element x are computed as SHA256(0x00 ||| x)
- internal element hashes for a note with left child hashing to l_hash and right child hashing to
r_hash is: SHA256(0x01 ||| l_hash ||| r_hash)
This ensures that no two trees with the same root hash can be computed.
This implementation has 128 bits of collision-resistance security if the attacker can choose the
value of leaves. If the attacker cannot control inserted leaves, then finding a collision is as
hard as chosen-preimage for SHA256.
*/
/**
* The maximum depth supported for the Merkle tree, where the root has depth 0.
* The maximum number of elements supported is therefore pow(2, MAX_MERKLE_TREE_DEPTH).
*/
#define MAX_MERKLE_TREE_DEPTH 32
/**
* Convenience method to compute the hash of an element for the Merkle tree, which is the SHA256
* hash of the input buffer, prepended with a 0x00 byte.
*
* @param[in] in
* Pointer to the input buffer.
* @param[in] in_len
* Length of the input buffer.
* @param[out] out
* Pointer to a 32-bytes buffer to store the result.
*/
void merkle_compute_element_hash(const uint8_t *in, size_t in_len, uint8_t out[static 32]);
/**
* Computes the hash for an internal node of the Merkle tree, given the hashes of its children.
* The result is the output of SHA256 on the concatenation of the byte 0x01, the left child hash,
* and the right child hash.
*
* @param[in] left
* Pointer to the input buffer.
* @param[in] right
* Length of the input buffer.
* @param[out] out
* Pointer to a 32-bytes buffer to store the result.
*/
void merkle_combine_hashes(const uint8_t left[static 32],
const uint8_t right[static 32],
uint8_t out[static 32]);
// inlined to save on stack depth
static inline uint8_t ceil_lg(uint32_t n) {
uint8_t r = 0;
uint32_t t = 1;
while (t < n) {
t = 2 * t;
++r;
}
return r;
}
// Returns the ith member of the directions array for the leaf with the given index in a Merkle tree
// of the given size. Returns -1 on error.
// TODO: make this O(log n), or possibly O(1). Currently O(log^2 n).
//
// inlined to save on stack depth (only used once anyway, so no impact on code size)
static inline int merkle_get_ith_direction(size_t size, size_t index, size_t i) {
if (size <= 1 || index >= size) {
return -1;
}
uint8_t n_directions = 0;
while (size > 1) {
uint8_t depth = ceil_lg(size);
// bitmask of the direction from the current node, where 0 = left, 1 = right;
// also the number of leaves of the left subtree
uint32_t mask = 1 << (depth - 1);
uint8_t is_right_child = (index & mask) != 0 ? 1 : 0;
if (n_directions == i) {
return is_right_child;
}
++n_directions;
if (is_right_child) {
size -= mask;
index -= mask;
} else {
size = mask;
}
mask /= 2;
}
return -1;
}
/**
* Represents the Merkleized version of a key-value map, holding the number of elements, the root of
* the Merkle tree of the sorted list of keys, and the root of the Merkle tree of the values (sorted
* by their correpsonding key).
*/
typedef struct {
uint64_t size;
uint8_t keys_root[32];
uint8_t values_root[32];
} merkleized_map_commitment_t; |
#ifndef MOTIONMODELS_H_
#define MOTIONMODELS_H_
/// ----------------------------------------------------------------------------
/// @file MotionModels.h
/// @author Kevin DeMarco <[email protected]>
///
/// Time-stamp: <2013-03-11 18:20:56 syllogismrxs>
///
/// @version 1.0
/// Created: 01 Feb 2013
///
/// ----------------------------------------------------------------------------
/// @section LICENSE
///
/// The MIT License (MIT)
/// Copyright (c) 2012 Kevin DeMarco
///
/// Permission is hereby granted, free of charge, to any person obtaining a
/// copy of this software and associated documentation files (the "Software"),
/// to deal in the Software without restriction, including without limitation
/// the rights to use, copy, modify, merge, publish, distribute, sublicense,
/// and/or sell copies of the Software, and to permit persons to whom the
/// Software is furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in
/// all copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
/// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
/// DEALINGS IN THE SOFTWARE.
/// ----------------------------------------------------------------------------
/// @section DESCRIPTION
///
/// The MotionModels class ...
///
/// ----------------------------------------------------------------------------
#include <boost/array.hpp>
#include <boost/numeric/odeint.hpp>
#include <cv.h>
using namespace boost::numeric::odeint;
namespace syllo {
////////////
/// typedef std::vector< double > state_type;
///
/// /* The rhs of x' = f(x) defined as a class */
/// class harm_osc {
///
/// double m_gam;
///
/// public:
/// harm_osc( double gam ) : m_gam(gam) { }
///
/// void operator() ( const state_type &x , state_type &dxdt , const double /* t */ )
/// {
/// dxdt[0] = x[1];
/// dxdt[1] = -x[0] - m_gam*x[1];
/// }
/// };
///
///////////
#define SYLLO_PI 3.14159265359
//typedef std::vector< double > state_type;
typedef boost::array< double, 1 > state_1d_type;
typedef boost::array< double , 3 > state_3d_type;
typedef boost::numeric::odeint::runge_kutta4< state_3d_type > stepper_3d_type;
//void write_cout( const double &x , const double t );
void write_cout( const double &x , const double t );
void write_lorenz( const state_3d_type &x , const double t );
void lorenz( const state_3d_type &x , state_3d_type &dxdt , double t );
void simple_rhs( const double x , double &dxdt , const double t );
void cart_model(const state_3d_type &x , state_3d_type &dxdt , double t);
void cart_trajectory(double t0, double dt, double tend,
std::vector<double> &xPos,
std::vector<double> &yPos,
std::vector<double> &heading,
std::vector<cv::Point2f> &cart_pos);
void addMotionNoise(std::vector<cv::Point2f> &input,
std::vector<cv::Point2f> &output);
//class MotionModels {
//private:
// int count_;
//
//protected:
//public:
// MotionModels();
//
// int count();
// void set_count(int count);
//};
}
#endif
|
#ifndef _KSYSCALLS_H_
#define _KSYSCALLS_H_
#include <kdefine.h>
#include <syscalls.h>
typedef uint64_t syscall_st(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t r10, uint64_t r8, uint64_t r9);
syscall_st syscall_read;
syscall_st syscall_write;
syscall_st syscall_time;
syscall_st syscall_terminal_select;
syscall_st syscall_terminal_clear;
syscall_st syscall_terminal_color;
syscall_st syscall_terminal_cursor;
syscall_st syscall_set_video_mode;
syscall_st syscall_paint_pixel;
syscall_st syscall_sound;
syscall_st syscall_new_process;
syscall_st syscall_ps;
syscall_st syscall_kill_process;
syscall_st syscall_block_process;
syscall_st syscall_waitpid;
syscall_st syscall_get_pid;
syscall_st syscall_read_message;
syscall_st syscall_send_message;
syscall_st syscall_has_message;
syscall_st syscall_play_note;
syscall_st syscall_sleep;
syscall_st syscall_rand;
syscall_st syscall_alloc;
// (2) FUTURE SYSCALL HERE !!
extern syscall_st * syscalls_table[_SYSCALLS_SIZE];
#endif
|
#pragma once
// types
#define ASN1_BOOL 0x1
#define ASN1_INT 0x2
#define ASN1_BIT_STR 0x3
#define ASN1_OCT_STR 0x4
#define ASN1_NULL 0x5
#define ASN1_OID 0x6
#define ASN1_SEQ 0x10
#define ASN1_SET 0x11
#define ASN1_UNIVERSAL 0x0
#define ASN1_APPLICATION 0x40
#define ASN1_CONTEXT 0x80
#define ASN1_PRIVATE 0xc0
#define ASN1_PRIMITIVE 0x0
#define ASN1_CONSTRUCTOR 0x20
#define ASN1_LONGLEN 0x80
typedef struct {
char *b;
int len;
} asn1_str_t;
typedef struct {
int *b;
int len;
} asn1_oid_t;
typedef struct {
int code;
int pos;
const char *message;
} asn1_error_t;
int asn1_cmp_oids(asn1_oid_t a, asn1_oid_t b);
int asn1_oid_has_prefix(asn1_oid_t a, asn1_oid_t b);
void asn1_set_error(asn1_error_t *s, int p, const char *m);
void asn1_free_oid(asn1_oid_t *id);
void asn1_free_str(asn1_str_t *s);
asn1_oid_t asn1_crt_oid(const int *id, int l);
asn1_oid_t *asn1_new_oid(const int *id, int l);
asn1_str_t *asn1_new_str(const char *msg, int l);
int asn1_dec_length(const char *b, int *i, int l);
int asn1_dec_int(const char *b, int *i, int l, int *val);
int asn1_dec_long(const char *b, int *i, int l, long long *val);
int asn1_dec_oid(const char *b, int *i, int l, asn1_oid_t *val);
int asn1_dec_string(const char *b, int *i, int l, asn1_str_t *val);
int asn1_dec_sequence(const char *b, int *i, int l, int (*c)(const char *b, int *i, int l, int tp, void *arg), void *arg);
int asn1_enc_null(char **b, int *i, int *l, int tp);
int asn1_enc_int(char **b, int *i, int *l, int tp, int val);
int asn1_enc_long(char **b, int *i, int *l, int tp, long long val);
int asn1_enc_oid(char **b, int *i, int *l, int tp, asn1_oid_t val);
int asn1_enc_string(char **b, int *i, int *l, int tp, asn1_str_t val);
int asn1_enc_sequence(char **b, int *i, int *l, int tp, int (*c)(char **b, int *i, int *l, void *arg), void *arg);
void asn1_dump_oid(asn1_oid_t d);
|
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
#pragma once
namespace Management
{
namespace RepairManager
{
class RepairTargetDescriptionBase;
typedef std::shared_ptr<RepairTargetDescriptionBase> RepairTargetDescriptionBaseSPtr;
class RepairTargetDescriptionBase
: public Serialization::FabricSerializable
, public Common::IFabricJsonSerializable
{
public:
RepairTargetDescriptionBase();
explicit RepairTargetDescriptionBase(RepairTargetKind::Enum kind);
RepairTargetDescriptionBase(RepairTargetDescriptionBase const &);
RepairTargetDescriptionBase(RepairTargetDescriptionBase &&);
__declspec(property(get = get_Kind)) RepairTargetKind::Enum const Kind;
RepairTargetKind::Enum const get_Kind() const { return kind_; }
virtual bool operator == (RepairTargetDescriptionBase const & other) const;
bool operator != (RepairTargetDescriptionBase const & other) const;
virtual Common::ErrorCode FromPublicApi(FABRIC_REPAIR_TARGET_DESCRIPTION const &);
virtual void ToPublicApi(__in Common::ScopedHeap &, __out FABRIC_REPAIR_TARGET_DESCRIPTION &) const;
virtual void WriteTo(Common::TextWriter&, Common::FormatOptions const &) const;
virtual bool IsValid() const;
virtual RepairTargetDescriptionBaseSPtr Clone() const;
// Needed for serialization activation feature
static Serialization::IFabricSerializable * FabricSerializerActivator(
Serialization::FabricTypeInformation typeInformation);
virtual NTSTATUS GetTypeInformation(
__out Serialization::FabricTypeInformation & typeInformation) const;
static RepairTargetDescriptionBase * CreateNew(FABRIC_REPAIR_TARGET_KIND kind);
static RepairTargetDescriptionBaseSPtr CreateSPtr(FABRIC_REPAIR_TARGET_KIND kind);
FABRIC_FIELDS_01(kind_);
BEGIN_JSON_SERIALIZABLE_PROPERTIES()
SERIALIZABLE_PROPERTY_ENUM(ServiceModel::Constants::Kind, kind_)
END_JSON_SERIALIZABLE_PROPERTIES()
JSON_TYPE_ACTIVATOR_METHOD(RepairTargetDescriptionBase, FABRIC_REPAIR_TARGET_KIND, kind_, CreateSPtr)
protected:
RepairTargetKind::Enum kind_;
};
template<FABRIC_REPAIR_TARGET_KIND Kind>
class RepairTargetSerializationTypeActivator
{
public:
static RepairTargetDescriptionBase * CreateNew()
{
return new RepairTargetDescriptionBase(RepairTargetKind::Invalid);
}
static RepairTargetDescriptionBaseSPtr CreateSPtr()
{
return make_shared<RepairTargetDescriptionBase>(RepairTargetKind::Invalid);
}
};
// template specializations, to be defined in derived classes
#define DEFINE_REPAIR_TARGET_ACTIVATOR(TYPE_SERVICEMODEL, IDL_ENUM) \
template<> class RepairTargetSerializationTypeActivator<IDL_ENUM> \
{ \
public: \
static RepairTargetDescriptionBase * CreateNew() \
{ \
return new TYPE_SERVICEMODEL(); \
} \
static RepairTargetDescriptionBaseSPtr CreateSPtr() \
{ \
return std::make_shared<TYPE_SERVICEMODEL>(); \
} \
}; \
}
}
|
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#include <sys/param.h>
#include <sys/types.h>
#include <sys/vmparam.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/stack.h>
#include <sys/frame.h>
#include <sys/proc.h>
#include <sys/ucontext.h>
#include <sys/siginfo.h>
#include <sys/cpuvar.h>
#include <sys/asm_linkage.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/bootconf.h>
#include <sys/archsystm.h>
#include <sys/fpu/fpusystm.h>
#include <sys/auxv.h>
#include <sys/debug.h>
#include <sys/elf.h>
#include <sys/elf_SPARC.h>
#include <sys/cmn_err.h>
#include <sys/spl.h>
#include <sys/privregs.h>
#include <sys/kobj.h>
#include <sys/modctl.h>
#include <sys/reboot.h>
#include <sys/time.h>
#include <sys/panic.h>
#include <vm/seg_kmem.h>
#include <vm/page.h>
#include <sys/machpcb.h>
extern struct bootops *bootops;
/*
* Workaround for broken FDDI driver (remove when 4289172 is fixed)
*/
short cputype = 0x80;
extern int getpcstack_top(pc_t *pcstack, int limit, uintptr_t *lastfp,
pc_t *lastpc);
/*
* Get a pc-only stacktrace. Used for kmem_alloc() buffer ownership tracking.
* Returns MIN(current stack depth, pcstack_limit).
*/
int
getpcstack(pc_t *pcstack, int pcstack_limit)
{
struct frame *fp, *minfp, *stacktop;
uintptr_t nextfp;
pc_t nextpc;
int depth;
int on_intr;
pc_t pcswin[MAXWIN];
int npcwin = MIN(MAXWIN, pcstack_limit);
if ((on_intr = CPU_ON_INTR(CPU)) != 0)
stacktop = (struct frame *)(CPU->cpu_intr_stack + SA(MINFRAME));
else
stacktop = (struct frame *)curthread->t_stk;
minfp = (struct frame *)((uintptr_t)getfp() + STACK_BIAS);
/*
* getpcstack_top() processes the frames still in register windows,
* fills nextfp and nextpc with our starting point, and returns
* the number of frames it wrote into pcstack.
*
* Since we cannot afford to take a relocation trap while we are
* messing with register windows, we pass getpcstack_top() a buffer
* on our stack and then copy the result out to the pcstack buffer
* provided by the caller. The size of this buffer is the maximum
* supported number of SPARC register windows; however we ASSERT
* that it returns fewer than that, since it will skip the current
* frame.
*/
npcwin = getpcstack_top(pcswin, npcwin, &nextfp, &nextpc);
ASSERT(npcwin >= 0 && npcwin < MAXWIN && npcwin <= pcstack_limit);
for (depth = 0; depth < npcwin; depth++) {
pcstack[depth] = pcswin[depth];
}
fp = (struct frame *)(nextfp + STACK_BIAS);
while (depth < pcstack_limit) {
if (fp <= minfp || fp >= stacktop) {
if (on_intr) {
/*
* Hop from interrupt stack to thread stack.
*/
stacktop = (struct frame *)curthread->t_stk;
minfp = (struct frame *)curthread->t_stkbase;
on_intr = 0;
continue;
}
break;
}
pcstack[depth++] = nextpc;
minfp = fp;
nextpc = (pc_t)fp->fr_savpc;
fp = (struct frame *)((uintptr_t)fp->fr_savfp + STACK_BIAS);
}
return (depth);
}
/*
* The following ELF header fields are defined as processor-specific
* in the SPARC V8 ABI:
*
* e_ident[EI_DATA] encoding of the processor-specific
* data in the object file
* e_machine processor identification
* e_flags processor-specific flags associated
* with the file
*/
/*
* The value of at_flags reflects a platform's cpu module support.
* at_flags is used to check for allowing a binary to execute and
* is passed as the value of the AT_FLAGS auxiliary vector.
*/
int at_flags = 0;
/*
* Check the processor-specific fields of an ELF header.
*
* returns 1 if the fields are valid, 0 otherwise
*/
int
elfheadcheck(
unsigned char e_data,
Elf32_Half e_machine,
Elf32_Word e_flags)
{
Elf32_Word needed_flags;
int supported_flags;
if (e_data != ELFDATA2MSB)
return (0);
switch (e_machine) {
case EM_SPARC:
if (e_flags == 0)
return (1);
else
return (0);
case EM_SPARCV9:
/*
* Check that ELF flags are set to supported SPARC V9 flags
*/
needed_flags = e_flags & EF_SPARC_EXT_MASK;
supported_flags = at_flags & ~EF_SPARC_32PLUS;
if (needed_flags & ~supported_flags)
return (0);
else
return (1);
case EM_SPARC32PLUS:
if ((e_flags & EF_SPARC_32PLUS) != 0 &&
((e_flags & ~at_flags) & EF_SPARC_32PLUS_MASK) == 0)
return (1);
else
return (0);
default:
return (0);
}
}
uint_t auxv_hwcap_include = 0; /* patch to enable unrecognized features */
uint_t auxv_hwcap_exclude = 0; /* patch for broken cpus, debugging */
#if defined(_SYSCALL32_IMPL)
uint_t auxv_hwcap32_include = 0; /* ditto for 32-bit apps */
uint_t auxv_hwcap32_exclude = 0; /* ditto for 32-bit apps */
#endif
uint_t cpu_hwcap_flags = 0; /* set by cpu-dependent code */
/*
* Gather information about the processor and place it into auxv_hwcap
* so that it can be exported to the linker via the aux vector.
*
* We use this seemingly complicated mechanism so that we can ensure
* that /etc/system can be used to override what the system can or
* cannot discover for itself.
*/
void
bind_hwcap(void)
{
auxv_hwcap = (auxv_hwcap_include | cpu_hwcap_flags) &
~auxv_hwcap_exclude;
if (auxv_hwcap_include || auxv_hwcap_exclude)
cmn_err(CE_CONT, "?user ABI extensions: %b\n",
auxv_hwcap, FMT_AV_SPARC);
#if defined(_SYSCALL32_IMPL)
/*
* These are now a compatibility artifact; all supported SPARC CPUs
* are V9-capable (and thus support v8plus) and fully implement
* {s,u}mul and {s,u}div.
*/
cpu_hwcap_flags |= AV_SPARC_MUL32 | AV_SPARC_DIV32 | AV_SPARC_V8PLUS;
auxv_hwcap32 = (auxv_hwcap32_include | cpu_hwcap_flags) &
~auxv_hwcap32_exclude;
if (auxv_hwcap32_include || auxv_hwcap32_exclude)
cmn_err(CE_CONT, "?32-bit user ABI extensions: %b\n",
auxv_hwcap32, FMT_AV_SPARC);
#endif
}
int
__ipltospl(int ipl)
{
return (ipltospl(ipl));
}
/*
* Print a stack backtrace using the specified stack pointer. We delay two
* seconds before continuing, unless this is the panic traceback.
* If we are in the process of panicking, we also attempt to write the
* stack backtrace to a staticly assigned buffer, to allow the panic
* code to find it and write it in to uncompressed pages within the
* system crash dump.
*
* Note that the frame for the starting stack pointer value is omitted because
* the corresponding %pc is not known.
*/
extern char *dump_stack_scratch;
void
traceback(caddr_t sp)
{
struct frame *fp = (struct frame *)(sp + STACK_BIAS);
struct frame *nextfp, *minfp, *stacktop;
int on_intr;
cpu_t *cpu;
uint_t offset = 0;
uint_t next_offset = 0;
char stack_buffer[2048];
char local_buffer[1024];
flush_windows();
if (!panicstr)
printf("traceback: %%sp = %p\n", (void *)sp);
if (panicstr && !dump_stack_scratch) {
printf("Warning - stack not written to the dumpbuf\n");
}
/*
* If we are panicking, the high-level interrupt information in
* CPU was overwritten. panic_cpu has the correct values.
*/
kpreempt_disable(); /* prevent migration */
cpu = (panicstr && CPU->cpu_id == panic_cpu.cpu_id)? &panic_cpu : CPU;
if ((on_intr = CPU_ON_INTR(cpu)) != 0)
stacktop = (struct frame *)(cpu->cpu_intr_stack + SA(MINFRAME));
else
stacktop = (struct frame *)curthread->t_stk;
kpreempt_enable();
minfp = fp;
while ((uintptr_t)fp >= KERNELBASE) {
uintptr_t pc = (uintptr_t)fp->fr_savpc;
ulong_t off;
char *sym;
nextfp = (struct frame *)((uintptr_t)fp->fr_savfp + STACK_BIAS);
if (nextfp <= minfp || nextfp >= stacktop) {
if (on_intr) {
/*
* Hop from interrupt stack to thread stack.
*/
stacktop = (struct frame *)curthread->t_stk;
minfp = (struct frame *)curthread->t_stkbase;
on_intr = 0;
continue;
}
break; /* we're outside of the expected range */
}
if ((uintptr_t)nextfp & (STACK_ALIGN - 1)) {
printf(" >> mis-aligned %%fp = %p\n", (void *)nextfp);
break;
}
if ((sym = kobj_getsymname(pc, &off)) != NULL) {
printf("%016lx %s:%s+%lx "
"(%lx, %lx, %lx, %lx, %lx, %lx)\n", (ulong_t)nextfp,
mod_containing_pc((caddr_t)pc), sym, off,
nextfp->fr_arg[0], nextfp->fr_arg[1],
nextfp->fr_arg[2], nextfp->fr_arg[3],
nextfp->fr_arg[4], nextfp->fr_arg[5]);
(void) snprintf(stack_buffer, sizeof (stack_buffer),
"%s:%s+%lx "
"(%lx, %lx, %lx, %lx, %lx, %lx) | ",
mod_containing_pc((caddr_t)pc), sym, off,
nextfp->fr_arg[0], nextfp->fr_arg[1],
nextfp->fr_arg[2], nextfp->fr_arg[3],
nextfp->fr_arg[4], nextfp->fr_arg[5]);
} else {
(void) printf("%016lx %p (%lx, %lx, %lx, "
"%lx, %lx, %lx)\n",
(ulong_t)nextfp, (void *)pc,
nextfp->fr_arg[0], nextfp->fr_arg[1],
nextfp->fr_arg[2], nextfp->fr_arg[3],
nextfp->fr_arg[4], nextfp->fr_arg[5]);
(void) snprintf(stack_buffer, sizeof (stack_buffer),
"%p (%lx, %lx, %lx, %lx, %lx, %lx) | ",
(void *)pc,
nextfp->fr_arg[0], nextfp->fr_arg[1],
nextfp->fr_arg[2], nextfp->fr_arg[3],
nextfp->fr_arg[4], nextfp->fr_arg[5]);
}
(void) snprintf(local_buffer, sizeof (local_buffer),
" %%l0-3: %016lx %016lx %016lx %016lx\n"
" %%l4-7: %016lx %016lx %016lx %016lx\n",
nextfp->fr_local[0], nextfp->fr_local[1],
nextfp->fr_local[2], nextfp->fr_local[3],
nextfp->fr_local[4], nextfp->fr_local[5],
nextfp->fr_local[6], nextfp->fr_local[7]);
if (panicstr && dump_stack_scratch) {
next_offset = offset + strlen(stack_buffer);
if (next_offset < STACK_BUF_SIZE) {
bcopy(stack_buffer, dump_stack_scratch + offset,
strlen(stack_buffer));
offset = next_offset;
} else {
/*
* In attempting to save the panic stack
* to the dumpbuf we have overflowed that area.
* Print a warning and continue to printf the
* stack to the msgbuf
*/
printf("Warning: stack in the dump buffer"
" may be incomplete\n");
}
}
printf("%s", local_buffer);
fp = nextfp;
minfp = fp;
}
if (!panicstr) {
printf("end of traceback\n");
DELAY(2 * MICROSEC);
} else if (dump_stack_scratch) {
dump_stack_scratch[offset] = '\0';
}
}
/*
* Generate a stack backtrace from a saved register set.
*/
void
traceregs(struct regs *rp)
{
traceback((caddr_t)rp->r_sp);
}
void
exec_set_sp(size_t stksize)
{
klwp_t *lwp = ttolwp(curthread);
lwp->lwp_pcb.pcb_xregstat = XREGNONE;
if (curproc->p_model == DATAMODEL_NATIVE)
stksize += sizeof (struct rwindow) + STACK_BIAS;
else
stksize += sizeof (struct rwindow32);
lwptoregs(lwp)->r_sp = (uintptr_t)curproc->p_usrstack - stksize;
}
/*
* Allocate a region of virtual address space, unmapped.
*
* When a hard-redzone (firewall) is in effect, redzone violations are
* caught by the hardware the instant they happen because the first byte
* past the logical end of a firewalled buffer lies at the start of an
* unmapped page. This firewalling is accomplished by bumping up the
* requested address allocation, effectively removing an additional page
* beyond the original request from the available virtual memory arena.
* However, the size of the allocation passed to boot, in boot_alloc(),
* doesn't reflect this additional page and fragmentation of the OBP
* "virtual-memory" "available" lists property occurs. Calling
* prom_claim_virt() for the firewall page avoids this fragmentation.
*/
void *
boot_virt_alloc(void *addr, size_t size)
{
return (BOP_ALLOC_VIRT((caddr_t)addr, size));
}
/*ARGSUSED*/
int
xcopyin_nta(const void *uaddr, void *kaddr, size_t count, int dummy)
{
return (xcopyin(uaddr, kaddr, count));
}
/*ARGSUSED*/
int
xcopyout_nta(const void *kaddr, void *uaddr, size_t count, int dummy)
{
return (xcopyout(kaddr, uaddr, count));
}
/*ARGSUSED*/
int
kcopy_nta(const void *from, void *to, size_t count, int dummy)
{
return (kcopy(from, to, count));
}
|
/////////////////////////////////////////////////////////////////
/*
Created by Berat Özdemir, January 24 , 2021.
*/
/////////////////////////////////////////////////////////////////
#include "../VPetLCD.h"
namespace V20 {
class AgeWeightScreen : public VPetLCD::Screen {
private:
uint16_t age;
uint16_t weight;
public:
AgeWeightScreen(uint16_t _age, uint16_t _weight) { age = _age;weight = _weight; };
void draw(VPetLCD* lcd);
void setAge(uint16_t _age) { age = _age; };
void setWeight(uint16_t _weight) { weight = _weight; };
};
} |
#include <stdlib.h>
#include "types.h"
void Free(void* ptr) {
free(ptr);
}
void Result_Free(Result result) {
free(result.error);
}
void Error_Free(Error error) {
free(error.error);
}
void Sequence_Free(Sequence sequence) {
free(sequence.error);
} |
/******************************************************************************
*******************************************************************************
Fuzed DS
relminator
http://rel.phatcode.net
*******************************************************************************
******************************************************************************/
#include <nds.h>
#include "Vector2df32.h"
#include "UTIL.h"
#include "GlobalConstants.h"
#include "Map2D.h"
#ifndef CAMERA_H
#define CAMERA_H
class Vector3Df32
{
public:
s32 x,y,z;
};
class Camera
{
public:
Camera();
~Camera();
void Update( s32 x, s32 y, int signx, int signy, s32 &offx, s32 &offy, Map2D &Map );
void Update( s32 x, s32 y, int signx, int signy, Map2D &Map );
void UpdatePaused( s32 &x, s32 &y, s32 PlayerX, s32 PlayerY, Map2D &Map );
void Look();
void Zoom( s32 value );
void SetMode( int v )
{
Mode = v;
}
const s32& GetEyeDistanceFromScreen() const
{
return EyeDistanceFromScreen;
}
private:
void Follow( s32 x, s32 y );
void Follow( s32 x, s32 y, Map2D &Map );
void Follow( s32 x, s32 y, int signx, int signy, Map2D &Map );
void Follow( s32 x, s32 y, int signx, int signy, int limit, Map2D &Map );
void Follow( s32 x, s32 y, int signx, int signy, s32 &offx, s32 &offy, Map2D &Map );
void FollowLimit( s32 &x, s32 &y, Map2D &Map );
Vector3Df32 Position;
Vector3Df32 Target;
Vector3Df32 Up;
s32 EyeDistanceFromScreen;
int Mode;
};
#endif // CAMERA_H
|
#pragma once
#include <FastLED.h>
#include "config.h"
extern int bri;
extern CRGB color;
extern CRGB leds[LED_WIDTH];
void fillColor();
void fillColor(const CRGB &c);
void fillColor(const CRGB &c, byte d);
void setBrightness(int b);
void fadeIn();
void fadeOut();
void show();
|
/*
* Copyright (c) 2016, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*/
#ifndef FATAL_INCLUDE_fatal_codec_varint_h
#define FATAL_INCLUDE_fatal_codec_varint_h
#include <fatal/math/numerics.h>
#include <array>
#include <iterator>
#include <type_traits>
#include <cassert>
namespace ftl {
namespace detail {
namespace varint_impl {
// the maximum amount of data units with (DataSize + 1) bits of data taken
// by the varint encoding, for a type that takes up ValueSize bytes
template <std::size_t ValueSize, std::size_t DataSize>
using size = std::integral_constant<
std::size_t,
DataSize < ValueSize ? (ValueSize - 1) / DataSize + 1 : 1
>;
auto constexpr byte_size = data_bits<char>::value;
auto constexpr byte_payload = byte_size - 1;
static_assert(size<1, byte_payload>::value == 1, "size mismatch");
static_assert(size<2, byte_payload>::value == 1, "size mismatch");
static_assert(size<3, byte_payload>::value == 1, "size mismatch");
static_assert(size<4, byte_payload>::value == 1, "size mismatch");
static_assert(size<5, byte_payload>::value == 1, "size mismatch");
static_assert(size<6, byte_payload>::value == 1, "size mismatch");
static_assert(size<7, byte_payload>::value == 1, "size mismatch");
static_assert(size<8, byte_payload>::value == 2, "size mismatch");
static_assert(size<9, byte_payload>::value == 2, "size mismatch");
static_assert(size<10, byte_payload>::value == 2, "size mismatch");
static_assert(size<11, byte_payload>::value == 2, "size mismatch");
static_assert(size<12, byte_payload>::value == 2, "size mismatch");
static_assert(size<13, byte_payload>::value == 2, "size mismatch");
static_assert(size<14, byte_payload>::value == 2, "size mismatch");
static_assert(size<15, byte_payload>::value == 3, "size mismatch");
static_assert(size<16, byte_payload>::value == 3, "size mismatch");
static_assert(size<17, byte_payload>::value == 3, "size mismatch");
static_assert(size<18, byte_payload>::value == 3, "size mismatch");
static_assert(size<19, byte_payload>::value == 3, "size mismatch");
static_assert(size<20, byte_payload>::value == 3, "size mismatch");
static_assert(size<21, byte_payload>::value == 3, "size mismatch");
static_assert(size<22, byte_payload>::value == 4, "size mismatch");
static_assert(size<23, byte_payload>::value == 4, "size mismatch");
static_assert(size<24, byte_payload>::value == 4, "size mismatch");
static_assert(size<25, byte_payload>::value == 4, "size mismatch");
static_assert(size<26, byte_payload>::value == 4, "size mismatch");
static_assert(size<27, byte_payload>::value == 4, "size mismatch");
static_assert(size<28, byte_payload>::value == 4, "size mismatch");
static_assert(size<29, byte_payload>::value == 5, "size mismatch");
static_assert(size<30, byte_payload>::value == 5, "size mismatch");
static_assert(size<31, byte_payload>::value == 5, "size mismatch");
static_assert(size<32, byte_payload>::value == 5, "size mismatch");
static_assert(size<33, byte_payload>::value == 5, "size mismatch");
static_assert(size<34, byte_payload>::value == 5, "size mismatch");
static_assert(size<35, byte_payload>::value == 5, "size mismatch");
static_assert(size<36, byte_payload>::value == 6, "size mismatch");
static_assert(size<37, byte_payload>::value == 6, "size mismatch");
static_assert(size<38, byte_payload>::value == 6, "size mismatch");
static_assert(size<39, byte_payload>::value == 6, "size mismatch");
static_assert(size<40, byte_payload>::value == 6, "size mismatch");
static_assert(size<41, byte_payload>::value == 6, "size mismatch");
static_assert(size<42, byte_payload>::value == 6, "size mismatch");
static_assert(size<43, byte_payload>::value == 7, "size mismatch");
static_assert(size<44, byte_payload>::value == 7, "size mismatch");
static_assert(size<45, byte_payload>::value == 7, "size mismatch");
static_assert(size<46, byte_payload>::value == 7, "size mismatch");
static_assert(size<47, byte_payload>::value == 7, "size mismatch");
static_assert(size<48, byte_payload>::value == 7, "size mismatch");
static_assert(size<49, byte_payload>::value == 7, "size mismatch");
static_assert(size<50, byte_payload>::value == 8, "size mismatch");
static_assert(size<51, byte_payload>::value == 8, "size mismatch");
static_assert(size<52, byte_payload>::value == 8, "size mismatch");
static_assert(size<53, byte_payload>::value == 8, "size mismatch");
static_assert(size<54, byte_payload>::value == 8, "size mismatch");
static_assert(size<55, byte_payload>::value == 8, "size mismatch");
static_assert(size<56, byte_payload>::value == 8, "size mismatch");
static_assert(size<57, byte_payload>::value == 9, "size mismatch");
static_assert(size<58, byte_payload>::value == 9, "size mismatch");
static_assert(size<59, byte_payload>::value == 9, "size mismatch");
static_assert(size<60, byte_payload>::value == 9, "size mismatch");
static_assert(size<61, byte_payload>::value == 9, "size mismatch");
static_assert(size<62, byte_payload>::value == 9, "size mismatch");
static_assert(size<63, byte_payload>::value == 9, "size mismatch");
static_assert(size<64, byte_payload>::value == 10, "size mismatch");
static_assert(size<65, byte_payload>::value == 10, "size mismatch");
static_assert(size<66, byte_payload>::value == 10, "size mismatch");
static_assert(size<67, byte_payload>::value == 10, "size mismatch");
static_assert(size<68, byte_payload>::value == 10, "size mismatch");
static_assert(size<69, byte_payload>::value == 10, "size mismatch");
static_assert(size<70, byte_payload>::value == 10, "size mismatch");
static_assert(size<byte_size * 1, byte_payload>::value == 2, "size mismatch");
static_assert(size<byte_size * 2, byte_payload>::value == 3, "size mismatch");
static_assert(size<byte_size * 3, byte_payload>::value == 4, "size mismatch");
static_assert(size<byte_size * 4, byte_payload>::value == 5, "size mismatch");
static_assert(size<byte_size * 5, byte_payload>::value == 6, "size mismatch");
static_assert(size<byte_size * 6, byte_payload>::value == 7, "size mismatch");
static_assert(size<byte_size * 7, byte_payload>::value == 8, "size mismatch");
static_assert(size<byte_size * 8, byte_payload>::value == 10, "size mismatch");
static_assert(size<byte_size * 9, byte_payload>::value == 11, "size mismatch");
static_assert(size<byte_size * 10, byte_payload>::value == 12, "size mismatch");
static_assert(size<byte_size * 11, byte_payload>::value == 13, "size mismatch");
static_assert(size<byte_size * 12, byte_payload>::value == 14, "size mismatch");
static_assert(size<byte_size * 13, byte_payload>::value == 15, "size mismatch");
static_assert(size<byte_size * 14, byte_payload>::value == 16, "size mismatch");
static_assert(size<byte_size * 15, byte_payload>::value == 18, "size mismatch");
static_assert(size<byte_size * 16, byte_payload>::value == 19, "size mismatch");
template <typename TData>
struct data_traits {
using data_unit = TData;
using unsigned_unit = typename std::make_unsigned<data_unit>::type;
static_assert(
std::is_integral<data_unit>::value,
"expected integral data unit"
);
static_assert(
data_bits<unsigned_unit>::value == data_bits<data_unit>::value,
"unsupported data unit"
);
static_assert(
data_bits<unsigned_unit>::value > 1,
"at least 2 bits of data needed"
);
using data_size = data_bits<unsigned_unit>;
using payload_size = std::integral_constant<
std::size_t, data_size::value - 1
>;
using continuation_bit = std::integral_constant<
unsigned_unit, static_cast<unsigned_unit>(1) << payload_size::value
>;
static_assert(
most_significant_bit(continuation_bit::value) == data_size::value,
"invalid continuation bit"
);
static_assert(
pop_count<continuation_bit::value>::value == 1,
"invalid continuation bit"
);
using filter_mask = std::integral_constant<
unsigned_unit,
static_cast<unsigned_unit>(~continuation_bit::value)
>;
static_assert(
most_significant_bit(filter_mask::value) == payload_size::value,
"invalid filter mask"
);
static_assert(
pop_count<filter_mask::value>::value == payload_size::value,
"invalid filter mask"
);
// the maximum amount of TData units taken by the varint encoding of a type T
template <typename T>
class size_for {
static_assert(std::is_integral<T>::value, "expected an integral");
static_assert(
std::is_same<typename std::decay<T>::type, T>::value,
"plain type expected"
);
public:
using type = size<data_bits<T>::value, payload_size::value>;
};
static unsigned_unit from(data_unit const &value) {
return *reinterpret_cast<unsigned_unit const *>(std::addressof(value));
}
static data_unit to(unsigned_unit const &value) {
return *reinterpret_cast<data_unit const *>(std::addressof(value));
}
};
template <bool, typename T>
struct value_traits {
using external = T;
using internal = external;
static_assert(std::is_unsigned<external>::value, "implementation mismatch");
static internal pre(external value) noexcept { return value; }
static external post(internal value) noexcept { return value; }
};
template <typename T>
struct value_traits<true, T> {
using external = T;
using internal = typename std::make_unsigned<external>::type;
static_assert(std::is_signed<external>::value, "implementation mismatch");
static_assert(sizeof(external) == sizeof(internal), "invalid integral");
static internal pre(external const &value) noexcept {
return (*reinterpret_cast<internal const *>(std::addressof(value)) << 1)
| (value < 0 ? 1 : 0);
}
static external post(internal value) noexcept {
value = (value >> 1) | ((value & 1) << (data_bits<internal>::value - 1));
return *reinterpret_cast<external const *>(std::addressof(value));
}
};
} // namespace varint_impl {
} // namespace detail {
// TODO: DOCUMENT
template <typename T>
struct varint {
using type = T;
private:
using shift_counter = smallest_fast_unsigned_integral<
most_significant_bit(data_bits_v<type>)
>;
using value_traits = detail::varint_impl::value_traits<
std::is_signed<type>::value, type
>;
using internal = typename value_traits::internal;
public:
// largest amount of `TData` written when encoding a value of type `type`
template <typename TData>
using max_size = typename detail::varint_impl::data_traits<TData>
::template size_for<type>::type;
// an automatically allocated buffer of `TData` able
// to hold any encoding of a value of type `type`
template <typename TData = char>
using automatic_buffer = std::array<TData, max_size<TData>::value>;
struct encoder {
explicit encoder(type const &value) noexcept:
value_(value_traits::pre(value))
{}
// TODO: RETURN SIZE?
template <typename TOutputIterator>
TOutputIterator operator ()(
TOutputIterator begin,
TOutputIterator const end
) noexcept {
using traits = detail::varint_impl::data_traits<
typename std::iterator_traits<TOutputIterator>::value_type
>;
using unsigned_unit = typename traits::unsigned_unit;
for (; begin != end; std::advance(begin, 1)) {
unsigned_unit data = value_ & traits::filter_mask::value;
value_ >>= traits::payload_size::value;
if (value_) {
*begin = traits::to(data | traits::continuation_bit::value);
} else {
*begin = traits::to(data);
continued_ = false;
return std::next(begin);
}
}
return begin;
}
void reset(type const &value) noexcept {
value_ = value;
continued_ = true;
}
// returns true if the encoding is done, false if it needs more data
bool done() const noexcept { return !continued_; }
// returns false if the encoding is done, true if it needs more data
bool operator !() const noexcept { return continued_; }
// returns true if the encoding is done, false if it needs more data
explicit operator bool() const noexcept { return !continued_; }
private:
internal value_;
bool continued_ = true;
};
// returns the iterator `i` to the first unused element of the output
// buffer such that [out, i) represents the data that have been encoded
// buffer must be able to fit at least `max_size<decltype(*out)>` elements
// TODO: RETURN SIZE?
template <typename TOutputIterator>
static TOutputIterator encode(
type value,
TOutputIterator out
) noexcept {
using traits = detail::varint_impl::data_traits<
typename std::iterator_traits<TOutputIterator>::value_type
>;
using unsigned_unit = typename traits::unsigned_unit;
for (internal x = value_traits::pre(value); ; std::advance(out, 1)) {
unsigned_unit data = x & traits::filter_mask::value;
x >>= traits::payload_size::value;
if (x) {
*out = traits::to(data | traits::continuation_bit::value);
} else {
*out = traits::to(data);
return std::next(out);
}
}
}
struct decoder {
// returns the iterator `i` to the first unused element such
// that [begin, i) represents the data that have been decoded
template <typename TInputIterator>
TInputIterator operator ()(
TInputIterator begin,
TInputIterator const end
) noexcept {
using traits = detail::varint_impl::data_traits<
typename std::iterator_traits<TInputIterator>::value_type
>;
for (; continuation_ && begin != end; std::advance(begin, 1)) {
assert(continuation_);
value_ |= static_cast<internal>(
traits::from(*begin) & traits::filter_mask::value
) << shift_;
shift_ += traits::payload_size::value;
continuation_ = traits::from(*begin) & traits::continuation_bit::value;
}
return begin;
}
// resets the internal structure of this decoder as if
// no data had been fed to it
void reset() noexcept {
value_ = 0;
shift_ = 0;
continuation_ = true;
}
// the value decoded so far
type value() const noexcept { return value_traits::post(value_); }
// returns true if the decoding is done, false if it needs more data
bool done() const noexcept { return !continuation_; }
// returns false if the decoding is done, true if it needs more data
bool operator !() const noexcept { return continuation_; }
// returns true if the decoding is done, false if it needs more data
explicit operator bool() const noexcept { return !continuation_; }
private:
internal value_ = 0;
shift_counter shift_ = 0;
bool continuation_ = true;
};
template <typename TInputIterator>
static std::pair<type, bool> decode(
TInputIterator begin,
TInputIterator end
) noexcept {
decoder decode;
decode(begin, end);
return std::make_pair(decode.value(), decode.done());
}
// TODO: bike-shed
template <typename TInputIterator>
static std::pair<type, bool> tracking_decode(
TInputIterator &begin,
TInputIterator end
) noexcept {
decoder decode;
begin = decode(begin, end);
return std::make_pair(decode.value(), decode.done());
}
};
} // namespace ftl {
#endif // FATAL_INCLUDE_fatal_codec_varint_h
|
/*-------------------------------------------------------------------------
*
* remote_xact.h
* POSTGRES global transaction mgmt code
*
*
* Copyright Zhao Wei ([email protected])
*
* src/include/access/remote_xact.h
*
*-------------------------------------------------------------------------
*/
#ifndef REMOTE_XACT_H
#define REMOTE_XACT_H
#include "access/xact.h"
typedef enum GTxnDD_Victim_Policy
{
KILL_OLDEST,
KILL_YOUNGEST,
KILL_MOST_ROWS_CHANGED,
KILL_LEAST_ROWS_CHANGED,
KILL_MOST_ROWS_LOCKED
} GTxnDD_Victim_Policy;
extern GTxnDD_Victim_Policy g_glob_txnmgr_deadlock_detector_victim_policy;
extern void perform_deadlock_detect();
extern void gdd_init();
extern void StartSubTxnRemote(const char *name);
extern void SendReleaseSavepointToRemote(const char *name);
extern void SendRollbackRemote(const char *txnid, bool xa_end);
extern void SendRollbackSubToRemote(const char *name);
extern bool Send1stPhaseRemote(const char *txnid);
extern void Send2ndPhaseRemote(const char *txnid);
extern void StartTxnRemote(StringInfo cmd);
extern char *MakeTopTxnName(TransactionId txnid, time_t now);
#endif // !REMOTE_XACT_H
|
#ifndef REGEXPERIENCE_AST_NODE_FACTORY_H
#define REGEXPERIENCE_AST_NODE_FACTORY_H
#include "ast_nodes/ast_node.h"
AstNode *create_constant (GNode *cst_context);
AstNode *create_anchor (GNode *cst_context,
AstNode *anchored_node);
AstNode *create_unary_operator (OperatorType operator_type,
AstNode *operand);
AstNode *create_binary_operator (OperatorType operator_type,
AstNode *left_operand,
AstNode *right_operand);
#endif /* REGEXPERIENCE_AST_NODE_FACTORY_H */
|
#pragma once
#include <qcolor.h>
class QVector3D;
class ObjectID
{
public:
explicit ObjectID(int m_id);
int getId() const;
QVector3D getIdAsColor() const;
static int getIdFromColor(QVector3D color);
void setId(int id);
void setId(QVector3D* color);
private:
int m_id;
static int color2Id(QVector3D* color);
static QVector3D id2Color(int id);
};
|
#include <R.h>
#include <R_ext/Error.h>
#include <Rdefines.h>
extern "C" {
SEXP r_application_create_application(SEXP r_name,
SEXP r_directory,
SEXP r_code,
SEXP r_environment);
SEXP r_application_get_name(SEXP r_application);
SEXP r_application_get_directory(SEXP r_application);
SEXP r_application_get_code(SEXP r_application);
SEXP r_application_get_environment(SEXP r_application);
SEXP r_application_get_packages(SEXP r_application);
SEXP r_application_get_call_stack(SEXP r_application);
SEXP r_application_add_package(SEXP r_application, SEXP r_package);
}
|
../../../../WXDevtool/WXDevTool/Source/WXTracing/UIButton+WXEnlargeArea.h |
/*
* Copyright 2019 The Polycube Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "../base/PortsTrunkBase.h"
#include "PortsTrunkAllowed.h"
class Ports;
using namespace polycube::service::model;
class PortsTrunk : public PortsTrunkBase {
public:
PortsTrunk(Ports &parent, const PortsTrunkJsonObject &conf);
virtual ~PortsTrunk();
/// <summary>
/// Allowed vlans
/// </summary>
std::shared_ptr<PortsTrunkAllowed> getAllowed(
const uint16_t &vlanid) override;
std::vector<std::shared_ptr<PortsTrunkAllowed>> getAllowedList() override;
void addAllowed(const uint16_t &vlanid,
const PortsTrunkAllowedJsonObject &conf) override;
void addAllowedList(
const std::vector<PortsTrunkAllowedJsonObject> &conf) override;
void replaceAllowed(const uint16_t &vlanid,
const PortsTrunkAllowedJsonObject &conf) override;
void delAllowed(const uint16_t &vlanid) override;
void delAllowedList() override;
void insertAllowed(const uint16_t vlan);
/// <summary>
/// Enable/Disable the native vlan feature in this trunk port
/// </summary>
bool getNativeVlanEnabled() override;
void setNativeVlanEnabled(const bool &value) override;
/// <summary>
/// VLAN that is not tagged in this trunk port
/// </summary>
uint16_t getNativeVlan() override;
void setNativeVlan(const uint16_t &value) override;
PortsTrunkJsonObject toJsonObject() override;
bool isAllowed(uint16_t vlan);
bool isNative(uint16_t vlan);
private:
bool native_vlan_enabled_;
uint16_t native_vlan_;
std::unordered_map<uint16_t, std::shared_ptr<PortsTrunkAllowed>> allowed_;
};
|
/* TRD : the internal single-threaded library includes this file
so it does not have to have the user repeat the work
so this file has to be protected from double inclusion
or the "more than one amtching layer" error kicks in
*/
#ifndef LFDS720_PAL_PROCESSOR
/****************************************************************************/
#if( defined _MSC_VER && defined _M_IX86 )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "x86"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
// TRD : 32-bit Intel varies from 32 to 128 bytes cache line length
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 128
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined _MSC_VER && (defined _M_X64 || defined _M_AMD64) )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "x86_64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
// TRD : Intel bring over two cache lines at once, always, unless disabled in BIOS
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined _MSC_VER && defined _M_IA64 )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "ia64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 64
#endif
/****************************************************************************/
#if( defined _MSC_VER && defined _M_ARM )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "arm"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
/* TRD : ARM is LL/SC and uses a reservation granule of 8 to 2048 bytes
so the isolation value used here is worst-case - be sure to set
this correctly, otherwise structures are painfully large
the test application has an argument, "-e", which attempts to
determine the ERG length
*/
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 2048
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __arm__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "arm"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
/* TRD : ARM32 is LL/SC and uses a reservation granule of 2 to 512 words,
where a word is 32 bits, so 8 to 2048 bytes
the ERG value used here is worst-case - be sure to set
this correctly, otherwise structures are painfully large
the test application has an argument, "-e", which attempts to
determine the ERG length
*/
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 2048
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __aarch64__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "aarch64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
/* TRD : ARM64 is LL/SC and uses a reservation granule of 2 to 512 words,
where a word is 32 bits, so 8 to 2048 bytes, same as ARM32
the ERG value used here is worst-case - be sure to set
this correctly, otherwise structures are painfully large
the test application has an argument, "-e", which attempts to
determine the ERG length
*/
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 2048
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __i386__ )
/* TRD : i386 has no atomic operations
i486 has everything but not DWCAS
i586 onwards has DWCAS
however, the GCC predefines make it impossible to differentiate between many 32-bit platforms
so here we only check for i386, which is always defined on 32-bit
and in the compiler abstraction layer we use the __GCC_HAVE_SYNC_COMPARE_AND_SWAP_N defines
*/
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "x86"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
// TRD : 32-bit Intel varies from 32 to 128 bytes cache line length
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 128
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __x86_64__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "x86_64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
// TRD : Intel bring over two cache lines at once, always, unless disabled in BIOS
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __alpha__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "alpha"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 64
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __ia64__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "ia64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 64
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __mips__ && __mips != 64 )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "mips"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 32
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __mips__ && __mips == 64 )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "mips64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 128
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __powerpc__ && !defined __powerpc64__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "powerpc"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 64
// TRD : this value is not very certain
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __powerpc64__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "powerpc64"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 128
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 128
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __sparc__ && !defined __sparc_v9__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "sparc"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 32
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __sparc__ && defined __sparc_v9__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long long lfds720_pal_int_t;
typedef int long long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "sparcv9"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 16
// TRD : yes, really
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 32
#endif
/****************************************************************************/
#if( defined __GNUC__ && defined __m68k__ )
#ifdef LFDS720_PAL_PROCESSOR
#error More than one porting abstraction layer matches the current platform in "lfds720_porting_abstraction_layer_processor.h".
#endif
#define LFDS720_PAL_PROCESSOR
typedef int long lfds720_pal_int_t;
typedef int long unsigned lfds720_pal_uint_t;
#define LFDS720_PAL_PROCESSOR_STRING "m68k"
#define LFDS720_PAL_SINGLE_POINTER_LENGTH_IN_BYTES 4
#define LFDS720_PAL_DOUBLE_POINTER_LENGTH_IN_BYTES 8
#define LFDS720_PAL_CACHE_LINE_LENGTH_IN_BYTES 32
#define LFDS720_PAL_ATOMIC_ISOLATION_LENGTH_IN_BYTES 32
#endif
/****************************************************************************/
#if( !defined LFDS720_PAL_PROCESSOR )
#error No matching porting abstraction layer in "lfds720_porting_abstraction_layer_processor.h".
#endif
#endif
|
/*
* This file is part of the Soletta (TM) Project
*
* Copyright (C) 2016 Intel Corporation. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <sol-bluetooth.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @file
* @brief Routines to handle Bluetooth GATT protocol
*
* The Bluetooth Generic Attribute Protocol (GATT) is a lightweight protocol
* on top of another protocol named ATT (Attribute Protocol), that defines the
* attribute has a type (UUID), a value, and is indentified by a handle.
*
* The API is based on the BlueZ D-Bus GATT API,
* @see https://git.kernel.org/cgit/bluetooth/bluez.git/tree/doc/gatt-api.txt
*/
/**
* @defgroup Bluetooth Bluetooth
* @ingroup Comms
*
* @brief API to handle the GATT protocol.
*
* @warning Experimental API. Changes are expected in future releases.
*
* @{
*/
/**
* @brief Set of types of Attributes
*
* GATT has the concept of different types of attributes, based on their UUIDs,
* sol-gatt simplifies that, separating attributes into three types.
*/
enum sol_gatt_attr_type {
SOL_GATT_ATTR_TYPE_INVALID,
SOL_GATT_ATTR_TYPE_SERVICE,
SOL_GATT_ATTR_TYPE_CHARACTERISTIC,
SOL_GATT_ATTR_TYPE_DESCRIPTOR,
};
/**
* @brief Set of flags for Charateristic attributes
*
* See the Bluetooth Core Specification, Table 3.5 and Table 3.8 for more details.
*/
enum sol_gatt_chr_flags {
/** @brief When set allows the characteristic value to be broadcast. */
SOL_GATT_CHR_FLAGS_BROADCAST = (1 << 0),
/** @brief Allows the characteristic value to be read. */
SOL_GATT_CHR_FLAGS_READ = (1 << 1),
/** @brief Allows the write without response procedure against the characteristic value */
SOL_GATT_CHR_FLAGS_WRITE_WITHOUT_RESPONSE = (1 << 2),
/** @brief Allows the characteristic value to be written */
SOL_GATT_CHR_FLAGS_WRITE = (1 << 3),
/** @brief Allows notifications for the characteristic value */
SOL_GATT_CHR_FLAGS_NOTIFY = (1 << 4),
/** @brief Allows indications for the characteristic value */
SOL_GATT_CHR_FLAGS_INDICATE = (1 << 5),
/** @brief Allows the authenticated signed write procedure against the characteristic value */
SOL_GATT_CHR_FLAGS_AUTHENTICATED_SIGNED_WRITES = (1 << 6),
/** @brief Allows the reliable write procedure against the characteristic value */
SOL_GATT_CHR_FLAGS_RELIABLE_WRITE = (1 << 7),
/** @brief Allows write operation against the descriptors associated with this characteristic */
SOL_GATT_CHR_FLAGS_WRITABLE_AUXILIARIES = (1 << 8),
/** @brief Only allows encrypted read operations against the characteristic value */
SOL_GATT_CHR_FLAGS_ENCRYPT_READ = (1 << 9),
/** @brief Only allows encrypted write operations against the characteristic value */
SOL_GATT_CHR_FLAGS_ENCRYPT_WRITE = (1 << 10),
/** @brief Only allows encrypted and authenticated read operations against
* the characteristic value
*/
SOL_GATT_CHR_FLAGS_ENCRYPT_AUTHENTICATED_READ = (1 << 11),
/** @brief Only allows encrypted and authenticated write operations against
* the characteristic value
*/
SOL_GATT_CHR_FLAGS_ENCRYPT_AUTHENTICATED_WRITE = (1 << 12),
};
/**
* @brief Set of flags for Descriptor attributes
*/
enum sol_gatt_desc_flags {
/** @brief Allows the descriptor value to be read. */
SOL_GATT_DESC_FLAGS_READ = (1 << 0),
/** @brief Allows the descriptor value to be written. */
SOL_GATT_DESC_FLAGS_WRITE = (1 << 1),
/** @brief Only allows encrypted read operations against the descriptor value. */
SOL_GATT_DESC_FLAGS_ENCRYPT_READ = (1 << 2),
/** @brief Only allows encrypted write operations against the descriptor value. */
SOL_GATT_DESC_FLAGS_ENCRYPT_WRITE = (1 << 3),
/**
* @brief Only allows encrypted and authenticated read operations against
* the descriptor value.
*/
SOL_GATT_DESC_FLAGS_ENCRYPT_AUTHENTICATED_READ = (1 << 4),
/**
* @brief Only allows encrypted and authenticated write operations against
* the descriptor value.
*/
SOL_GATT_DESC_FLAGS_ENCRYPT_AUTHENTICATED_WRITE = (1 << 5),
};
/**
* @typedef sol_gatt_pending
* @brief Represents a pending request
*
* So a response to a GATT operation can be returned asynchronously,
* operation callbacks, @see sol_gatt_attr, passes a pending operation
* to the user which calls sol_gatt_pending_reply() when the operation
* is complete.
*/
struct sol_gatt_pending;
typedef struct sol_gatt_pending sol_gatt_pending;
/**
* @brief Returns the attribute referenced by a pending operation
*
* @param op The pending operation
*
* @return reference to an attribute
*/
const struct sol_gatt_attr *sol_gatt_pending_get_attr(
const struct sol_gatt_pending *op);
/**
* @brief Representation of a GATT Attribute
*/
typedef struct sol_gatt_attr {
struct sol_bt_uuid uuid;
enum sol_gatt_attr_type type;
uint16_t flags;
/**
* The response for this operation will be returned by calling
* #sol_gatt_pending_reply() passing a valid buffer, or an error.
*/
int (*read)(struct sol_gatt_pending *op,
uint16_t offset);
/**
* The response for this operation will be returned by calling
* #sol_gatt_pending_reply(), the @a buf parameter will be ignored.
*
* @param op The pending operation.
* @param buf The buffer that will be written into the attribute,
* If the function returns success, it takes the ownership
* of the buffer.
* @param offset The offset into which the write operation was made.
*
* @return 0 on success, -errno on failure.
*/
int (*write)(struct sol_gatt_pending *op,
struct sol_buffer *buf,
uint16_t offset);
void *user_data;
void *_priv;
} sol_gatt_attr;
/**
* @brief Returns a response to an asynchronous operation
*
* When a operation is performed in a attribute, the response to the operation
* is only returned when this function is called.
*
* @param pending Pending operation to be responded.
* @param error Error to be returned, 0 on success.
* @param buf Payload (can be NULL) to be returned, on success the payload
* ownership passes to the function.
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_pending_reply(struct sol_gatt_pending *pending,
int error,
struct sol_buffer *buf);
/**
* @brief Helper to the construction of a GATT Service with 16-bit UUID.
*
* @see sol_gatt_attr
*/
#define SOL_GATT_SERVICE_UUID_16(service_uuid) \
{ .type = SOL_GATT_ATTR_TYPE_SERVICE, \
.uuid = { .type = SOL_BT_UUID_TYPE_16, \
.val16 = (service_uuid) } }
/**
* @brief Helper to the construction of a GATT Characteristic with 16-bit UUID.
*
* @see sol_gatt_attr
*/
#define SOL_GATT_CHARACTERISTIC_UUID_16(_uuid, _flags, ...) \
{ .type = SOL_GATT_ATTR_TYPE_CHARACTERISTIC, \
.uuid = { .type = SOL_BT_UUID_TYPE_16, \
.val16 = (_uuid) }, \
.flags = (_flags), \
__VA_ARGS__ }
/**
* @brief Helper to the construction of a GATT Descriptor with 16-bit UUID.
*
* @see sol_gatt_attr
*/
#define SOL_GATT_DESCRIPTOR_UUID_16(_uuid, _flags, ...) \
{ .type = SOL_GATT_ATTR_TYPE_DESCRIPTOR, \
.uuid = { .type = SOL_BT_UUID_TYPE_16, \
.val16 = (_uuid) }, \
.flags = (_flags), \
__VA_ARGS__ }
/**
* @brief Terminates the list of attributes.
*
* @see sol_gatt_register_attributes()
*/
#define SOL_GATT_ATTR_INVALID { .type = SOL_GATT_ATTR_TYPE_INVALID }
/**
* @brief Registers attributes into the GATT database
*
* @param attrs Array of the attributes to be registered
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_register_attributes(struct sol_gatt_attr *attrs);
/**
* @brief Unregisters attributes from the GATT database
*
* @param attrs Array of the attributes to be unregistered
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_unregister_attributes(struct sol_gatt_attr *attrs);
/**
* @brief Reads the value from a attribute
*
* This only really makes sense for Characteristics and Descriptors,
* the Read Long attribute procedure will be performed if it's supported.
*
* @param conn Connection to a remote device
* @param attr Attribute to be read
* @param cb Callback to be called when the operation is finished
* @param user_data User pointer to be passed to the callback
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_read_attr(struct sol_bt_conn *conn, struct sol_gatt_attr *attr,
void (*cb)(void *user_data, bool success,
const struct sol_gatt_attr *attr,
const struct sol_buffer *buf),
const void *user_data);
/**
* @brief Writes the value to a attribute
*
* This only really makes sense for Characteristics and Descriptors,
* the Write Long attribute procedure will be performed if it's supported.
*
* @param conn Connection to a remote device
* @param attr Attribute to be written
* @param buf Buffer to be written, on success the ownership passes to the function.
* @param cb Callback to be called when the operation is finished
* @param user_data User pointer to be passed to the callback
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_write_attr(struct sol_bt_conn *conn, struct sol_gatt_attr *attr,
struct sol_buffer *buf,
void (*cb)(void *user_data, bool success,
const struct sol_gatt_attr *attr),
const void *user_data);
/**
* @brief Discover attributes by type, restricted by UUID and parent attribute.
*
* Discover attributes belonging to a parent attribute, for example,
* discover all the characteristics under a service or all the
* descriptors under a characteristic, matching uuid (if provided).
*
* @param conn Connection to a remote device
* @param type If different from #SOL_GATT_ATTR_TYPE_INVALID, only consider attributes
* of @a type, @see sol_gatt_attr_type.
* @param parent If different from NULL, only consider attributes belonging
* to @a parent attribute.
* @param uuid If different from NULL, only consider attributes matching @a uuid.
* @param cb Callback to be called when the conditions above are met.
* @param user_data User pointer to be passed to the callback
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_discover(struct sol_bt_conn *conn, enum sol_gatt_attr_type type,
const struct sol_gatt_attr *parent,
const struct sol_bt_uuid *uuid,
bool (*cb)(void *user_data, struct sol_bt_conn *conn,
const struct sol_gatt_attr *attr),
const void *user_data);
/**
* Registers a callback to be called when a notification/indication is received.
*
* It will also try to enable indications/nofications writing to the
* CCC attribute if that descriptor exists.
*
* @param conn Connection to a remote device
* @param attr Attribute which to enable Notifications/Indications
* @param cb Callback to be called for each update, if you want the notification
* to be cancelled, return @a false.
* @param user_data User pointer to be passed to the callback
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_subscribe(struct sol_bt_conn *conn, const struct sol_gatt_attr *attr,
bool (*cb)(void *user_data, const struct sol_gatt_attr *attr,
const struct sol_buffer *buffer),
const void *user_data);
/**
* Unregisters from receiving notifications indications
*
* @param cb Callback previously set
* @param user_data User pointer
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_unsubscribe(bool (*cb)(void *user_data, const struct sol_gatt_attr *attr,
const struct sol_buffer *buffer),
const void *user_data);
/**
* Sends an indication to the device represented by @a conn. If @a
* conn is @c NULL, it sends to all devices that have registered
* themselves via the CCC attribute.
*
* The value to be indicated is the value retrieved by calling the @a
* read callback of the attribute.
*
* @param conn Connection in which to send notificatiions/indications.
* @param attr Attribute to update.
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_indicate(struct sol_bt_conn *conn, const struct sol_gatt_attr *attr);
/**
* Sends a notificatiion to the device represented by @a conn. If @a
* conn is @c NULL, it sends to all devices that have registered
* themselves via the CCC attribute.
*
* The value to be notified is the value retrieved by calling the @a
* read callback of the attribute.
*
* @param conn Connection in which to send notificatiions/indications.
* @param attr Attribute to update.
*
* @return 0 on success, -errno on failure.
*/
int sol_gatt_notify(struct sol_bt_conn *conn, const struct sol_gatt_attr *attr);
/**
* @}
*/
#ifdef __cplusplus
}
#endif
|
#ifndef TU7_ADDRS_H
#define TU7_ADDRS_H
namespace TU7
{
void* (*R_RegisterFont)(const char* r3, int r4) = reinterpret_cast<void* (*)(const char*, int)>(0x821B7E40);
void* (*R_AddCmdDrawText)(const char* r3, int r4, void* r5, float f1, float f2, float f3, float f4, float f5, const float* color, int something) = reinterpret_cast<void* (*)(const char* r3, int r4, void* r5, float f1, float f2, float f3, float f4, float f5, const float* color, int something)>(0x82401C30);
int(__cdecl* UI_TextWidth)(const char* text, int maxChars, int* font, float scale) = reinterpret_cast<int(__cdecl*)(const char* text, int maxChars, int* font, float scale)>(0x8229B6E0);
int(__cdecl* UI_TextHeight)(int* font, float scale) = reinterpret_cast<int(__cdecl*)(int* font, float scale)>(0x8229B748);
int(__cdecl* R_TextWidth)(const char* text, int maxchars, void* font) = reinterpret_cast<int(__cdecl*)(const char*, int, void*)>(0x823FFF28);
int(__cdecl* R_TextHeight)(void* font) = reinterpret_cast<int(__cdecl*)(void* font)>(0x82400018);
void(*R_AddCmdDrawTextWithEffects)(const char* text, int maxChars, void* font, float x, float y, float xScale, float yScale, float rotation, const float* color, int style, const float* glowColor, void* fxMaterial, void* fxMaterialGlow, int fxBirthTime, int fxLetterTime, int fxDecayStartTime, int fxDecayDuration) = reinterpret_cast<void(*)(const char* text, int maxChars, void* font, float x, float y, float xScale, float yScale, float rotation, const float* color, int style, const float* glowColor, void* fxMaterial, void* fxMaterialGlow, int fxBirthTime, int fxLetterTime, int fxDecayStartTime, int fxDecayDuration)>(0x82401F48);
void(*DrawText2D)(const char* text, float x, float y, void* font, float xScale, float yScale, float sinAngle, float cosAngle, float* color, int maxLength, int renderFlags, int cursorPos, char cursorLetter, float padding, float* glowForcedColor, int fxBirthTime, int fxLetterTime, int fxDecayStartTime, int fxDecayDuration, void* fxMaterial, void* fxMaterialGlow) = reinterpret_cast<void(*)(const char*, float, float, void*, float, float, float, float, float*, int, int, int, char, float, float*, int, int, int, int, void*, void*)>(0x82414E28);
void* (*Material_RegisterHandle)(const char* r3, int r4) = reinterpret_cast<void* (*)(const char*, int)>(0x824006F0);
int(*Material_RegisterHandleInt)(const char* r3, int r4) = reinterpret_cast<int(*)(const char*, int)>(0x824006F0);
void* (*R_AddCmdDrawStretchPic)(float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, const float* color, void* material) = reinterpret_cast<void* (*)(float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, const float* color, void* material)>(0x82401410);
void(*CG_GameMessage)(int localClientNum, const char* msg) = reinterpret_cast<void(*)(int, const char*)>(0x8216EC68);
void(*CG_GameMessageBold)(int localClientNum, const char* msg) = reinterpret_cast<void(*)(int, const char*)>(0x8216EC88);
void(*Cbuf_AddText)(int localClientNum, const char* text) = reinterpret_cast<void(*)(int, const char*)>(0x8226FF08);
int(*Dvar_GetInt)(const char* dvarName) = reinterpret_cast<int(*)(const char*)>(0x822BE158);
bool(*Dvar_GetBool)(const char* dvarName) = reinterpret_cast<bool(*)(const char*)>(0x822BE0E8);
const char* (*Dvar_GetString)(const char* dvarName) = reinterpret_cast<const char* (*)(const char*)>(0x822BE230);
float (*Dvar_GetFloat)(char const* dvarName) = reinterpret_cast<float(*)(const char*)>(0x822BE1C0);
void(*CL_Disconnect)(int localClientNum) = reinterpret_cast<void(*)(int)>(0x821B5088);
void(*CG_DrawClientPing)(int localClientNum, int ping, float x, float y, float maxWidth, float maxHeight) = reinterpret_cast<void(*)(int, int, float, float, float, float)>(0x82180698);
void(*CG_DrawOverheadNames)(int localClientNum, Centity_t* ent, float alpha) = reinterpret_cast<void(*)(int, Centity_t*, float)>(0x82159B48);
void(*ClientUserInfoChanged)(int localClientNum) = reinterpret_cast<void(*)(int)>(0x8220A8E0);
void(*toggleConsole)() = reinterpret_cast<void(*)()>(0x821A99F0);
void(*Sys_ShowIP)() = reinterpret_cast<void(*)()>(0x822E5AE8);
void(*SendCommandToConsole)(int localClientNum, const char* text) = reinterpret_cast<void(*)(int, const char*)>(0x82270D68);
//int(__cdecl* SL_GetString)(char*, int usr) = reinterpret_cast<int(__cdecl*)(char*, int)>(0x8233B7A0);
int(*Com_GetClientDObj)(int r3, int r4) = reinterpret_cast<int(*)(int, int)>(0x822758E8);
bool(*CG_DObjGetWorldTagPos)(Centity_t* r3, int r4, int r5, Vector3& r6) = reinterpret_cast<bool(*)(Centity_t*, int, int, Vector3&)>(0x82161EA8);
//int(*AimTarget_GetTagPos)(int localClientNum, Centity_t* cent, short tagName, Vector3& pos) = reinterpret_cast<int(*)(int, Centity_t*, short, Vector3&)>(0x82123C08);
static void(__cdecl* CG_DrawRotatedPicPhysical)(int, float, float, float, float, float, float*, void*) = reinterpret_cast<void(__cdecl*)(int, float, float, float, float, float, float*, void*)>(0x8215CEC0);
void(*BG_GetSpreadForWeapon)(cg_t* pps, int weaponinfo, float* minspread, float* maxspread) = reinterpret_cast<void(*)(cg_t*, int, float*, float*)>(0x82141650);
void(*Bullet_RandomDir)(int seed, float* x, float* y) = reinterpret_cast<void(*)(int, float*, float*)>(0x822046D0);
static void(*CG_DrawGrenadePointer)(int localClientNum, float centerX, float centerY, Vector3& grenadeOffset, float* color, const float radiusOffset, const float scaleFactor) = reinterpret_cast<void(*)(int, float, float, Vector3&, float*, float, float)>(0x82156838);
static void(*CG_CompassDrawPlayerMap)(int localClientNum, CompassType compassType, rectDef_s* parentRect, rectDef_s* rect, void* material, float* color) = reinterpret_cast<void(*)(int, CompassType, rectDef_s*, rectDef_s*, void*, float*)>(0x82150B48);
void(__cdecl* CG_CompassDrawFriendlies)(int localClientNum, CompassType compassType, rectDef_s* parentRect, rectDef_s* rect, float* color) = reinterpret_cast<void(*)(int, CompassType, rectDef_s*, rectDef_s*, float*)>(0x82153828);
void(__cdecl* CG_CompassDrawEnemies)(int localClientNum, CompassType compassType, rectDef_s* parentRect, rectDef_s* rect, float* color) = reinterpret_cast<void(*)(int, CompassType, rectDef_s*, rectDef_s*, float*)>(0x82154680);
void(__cdecl* CG_CompassDrawVehicles)(int localClientNum, CompassType compassType, int eType, rectDef_s* parentRect, rectDef_s* rect, void* enemyMaterial, void* friendlyMaterial, const float* color) = reinterpret_cast<void(*)(int, CompassType, int, rectDef_s*, rectDef_s*, void*, void*, const float*)>(0x82154DD8);
void(__cdecl* CG_CompassDrawVehicles_0)(int localClientNum, CompassType compassType, int eType, rectDef_s* parentRect, rectDef_s* rect, void* enemyMaterial, void* friendlyMaterial, const float* color) = reinterpret_cast<void(*)(int, CompassType, int, rectDef_s*, rectDef_s*, void*, void*, const float*)>(0x821553A0);
void(__cdecl* CG_CompassDrawPlayer)(int localClientNum, CompassType compassType, rectDef_s* parentRect, rectDef_s* rect, void* material, float* color) = reinterpret_cast<void(*)(int, CompassType, rectDef_s*, rectDef_s*, void*, float*)>(0x821510A0);
void(__cdecl* CG_CompassDrawBorder)(int localClientNum, CompassType compassType, rectDef_s* parentRect, rectDef_s* rect, void* material, float* color) = reinterpret_cast<void(*)(int, CompassType, rectDef_s*, rectDef_s*, void*, float*)>(0x82151300);
int (*CG_GetWeaponIndexForName)(const char* name) = reinterpret_cast<int(*)(const char*)>(0x82144FF8);
int (*Key_Down)(int localClientNum, int buttonEnum) = reinterpret_cast<int(*)(int, int)>(0x821B2908);
int(__cdecl* CL_GetCurrentCmdNumber)(int localClientNum) = reinterpret_cast<int(*)(int)>(0x821A4108);
unsigned int(__cdecl* GScr_AllocString)(const char*) = reinterpret_cast<unsigned int(__cdecl*)(const char*)>(0x8222D368);
const char* (__cdecl* Con_GetVersionString)() = reinterpret_cast<const char* (*)()>(0x821AB0A8);
char* (__cdecl* getBuildNumber)() = reinterpret_cast<char* (*)()>(0x82264298);
void(__cdecl* CG_GetRankIcon)(int rank, int prestige, Material** mat) = reinterpret_cast<void(*)(int, int, Material**)>(0x821BE9F8);
bool(*CG_WorldPosToCompass)(CompassType compassType, cg_t* cgameGlob, rectDef_s* mapRect, const float* north, const float* playerWorldPos, const float* in, float* out, float* outClipped) = reinterpret_cast<bool(*)(CompassType, cg_t*, rectDef_s*, const float*, const float*, const float*, float*, float*)>(0x8214FB20);
Vector3(*CL_GetMapCenter)() = reinterpret_cast<Vector3(*)()>(0x821B7E70);
char* (__cdecl* UI_GetMapDisplayName)(const char* mapname) = reinterpret_cast<char* (*)(const char*)>(0x8229F7A0);
char* (__cdecl* UI_GetGameTypeDisplayName)(const char* gametype) = reinterpret_cast<char* (*)(const char*)>(0x8229FA18);
int(__cdecl* irand)(int min, int max) = reinterpret_cast<int(*)(int, int)>(0x822B8290);
int(__cdecl* RandWithSeed)(int*) = reinterpret_cast<int(*)(int*)>(0x822B5160);
bool(__cdecl* AimTarget_IsTargetVisible)(int localClientNum, Centity_t* targetEnt, unsigned int visBone) = reinterpret_cast<bool(*)(int, Centity_t*, unsigned int)>(0x82125E70);
bool(__cdecl* AimTarget_IsTargetValid)(cg_t* cgameGlob, Centity_t* targetEnt) = reinterpret_cast<bool(*)(cg_t*, Centity_t*)>(0x82125960);
static void(__cdecl* CG_GetPlayerViewOrigin)(int localClientNum, cg_t* cg, Vector3& origin) = reinterpret_cast<void(__cdecl*)(int, cg_t* cg, Vector3&)>(0x8219BD50);
static void(*CG_LocationalTrace)(trace_t* results, Vector3* start, Vector3* end, int passEntityNum, int contentMask) = reinterpret_cast<void(*)(trace_t* results, Vector3* start, Vector3* end, int passEntityNum, int contentMask)>(0x821A2C58);
int(__cdecl* CG_PlayClientSoundAliasByName)(int localClientNum, const char* aliasname) = reinterpret_cast<int(*)(int, const char*)>(0x821717B0);
PCHAR(*va)(PCHAR format, ...) = reinterpret_cast<PCHAR(*)(PCHAR, ...)>(0x822C38D8);
unsigned int(*__cdecl SL_FindLowercaseString)(const char* tagName) = reinterpret_cast<unsigned int(*)(const char*)>(0x8233B1C8);
char* (*SL_ConvertToString)(unsigned int stringValue) = reinterpret_cast<char* (*)(unsigned int)>(0x8233AD40);
int(*SL_GetStringOfSize)(int localClientNum, char* txt, int type, unsigned int len) = reinterpret_cast<int(*)(int, char*, int, unsigned int)>(0x8233B2D8);
void(__cdecl* FireBulletPenetrate)(int LocalClient, BulletFireParams* bullet, int Weapon, Centity_t* MyCentity, float* viewOrg, bool drawTracer) = reinterpret_cast<void(__cdecl*)(int LocalClient, BulletFireParams* bullet, int Weapon, Centity_t* MyCentity, float* viewOrg, bool drawTracer)>(0x8219F6D0);
inline int SL_GetString(char* tag, int localClientNum)
{
return SL_GetStringOfSize(localClientNum, tag, 2, strlen(tag) + 1);
}
inline bool Aimtarget_GetTagPos(int cen, int tag, Vector3& tagpos) {
auto meh = Com_GetClientDObj(cen, 0);
if (meh == 0) {
return false;
}
return CG_DObjGetWorldTagPos(&Centity_s[cen], meh, tag, tagpos);
}
inline int TextWidth(const char* text, const char* font) {
return R_TextWidth(text, 0x7FFFFFFF, R_RegisterFont(font, 0));
}
inline int TextHeight(const char* font) {
return R_TextHeight(R_RegisterFont(font, 0));
}
inline bool checkLocalClient(int i) {
return i == cg->clientNum;
}
inline bool checkFFAMode() {
if (cgs->GameType == "oic" || cgs->GameType == "dm") return true;
return false;
}
inline bool notTeam(int i) {
return (cg->ClientInfo[cg->clientNum].mTeam != cg->ClientInfo[i].mTeam || cg->ClientInfo[i].mTeam == 0);
}
inline int ValidPlayerCount() {
auto count = 0;
for (auto i = 0; i < cgs->maxClients; i++) {
if (cg->ClientInfo[i].mValid) count++;
}
return count;
};
/*inline char* getIpAsString(int i) {
if (i == cg->clientNum) partydata.partyMembers[i].ExternalIP.ip1 = 0x00, partydata.partyMembers[i].ExternalIP.ip2 = 0x00, partydata.partyMembers[i].ExternalIP.ip3 = 0x00, partydata.partyMembers[i].ExternalIP.ip4 = 0x00;
return va("%d.%d.%d.%d", partydata.partyMembers[i].ExternalIP.ip1, partydata.partyMembers[i].ExternalIP.ip2, partydata.partyMembers[i].ExternalIP.ip3, partydata.partyMembers[i].ExternalIP.ip4);
}*/
inline char* getIpAsString(int i)
{
return va("%d.%d.%d.%d", partydata.partyMembers[i].ExternalIP.ip1, partydata.partyMembers[i].ExternalIP.ip2, partydata.partyMembers[i].ExternalIP.ip3, partydata.partyMembers[i].ExternalIP.ip4);
}
}
#endif // TU7_ADDRS_H
|
#include <stdio.h>
int main()
{
int i;
/* do some math */
i = 1 + 2 + 3;
/* do some math */
i=i+i;
printf("i = %i\n",i);
}
|
/**********************************************************************************************************************
This file is part of the Control Toolbox (https://github.com/ethz-adrl/control-toolbox), copyright by ETH Zurich.
Licensed under the BSD-2 license (see LICENSE file in main directory)
**********************************************************************************************************************/
#pragma once
#include <cppad/cg.hpp>
#include <cppad/cppad.hpp>
namespace ct {
namespace core {
typedef CppAD::AD<double> ADScalar;
typedef CppAD::cg::CG<double> ADCGValueType;
typedef CppAD::AD<ADCGValueType> ADCGScalar; //!< scalar type
}
}
|
/**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include "logdevice/common/Request.h"
#include "logdevice/common/protocol/FixedSizeMessage.h"
namespace facebook { namespace logdevice {
/**
* @file Message sent by the client library to storage nodes to update the
* trim point for the log. Once acknowledged, storage nodes shouldn't
* deliver records with LSNs smaller than or equal to the trim point.
*/
struct TRIM_Header {
request_id_t client_rqid; // id of TrimRequest; used for replies
logid_t log_id;
lsn_t trim_point;
shard_index_t shard;
// Return the expected size of the header given a protocol version.
static size_t getExpectedSize(uint16_t proto);
} __attribute__((__packed__));
class TRIM_Message : public Message {
public:
explicit TRIM_Message(const TRIM_Header& header)
: Message(MessageType::TRIM, TrafficClass::TRIM), header_(header) {}
void serialize(ProtocolWriter&) const override;
static Message::deserializer_t deserialize;
Disposition onReceived(const Address&) override;
void onSent(Status st, const Address& to) const override;
const TRIM_Header& getHeader() const {
return header_;
}
private:
TRIM_Header header_;
};
}} // namespace facebook::logdevice
|
/* RTcmix - Copyright (C) 2005 The RTcmix Development Team
See ``AUTHORS'' for a list of contributors. See ``LICENSE'' for
the license to this software and for a DISCLAIMER OF ALL WARRANTIES.
*/
#ifndef _ODCBLOCK_H_
#define _ODCBLOCK_H_ 1
// Simple DC-blocking filter, based on the method employed in STK.
// Default coefficient is .99, as it is in STK, but making this a little
// higher (say, .995, by calling setcoeff) will steepen the slope of the
// high-pass filter, reducing the impact on frequencies higher than DC. -JGG
class Odcblock {
public:
Odcblock();
~Odcblock();
inline float next(float input);
float last() const { return _last; }
void clear() { _hist = _last = 0.0; }
void setcoeff(const float coeff) { _coeff = coeff; }
private:
float _hist;
float _last;
float _coeff;
};
inline float Odcblock::next(float input)
{
_last = input - _hist + (_coeff * _last);
_hist = input;
return _last;
}
#endif // _ODCBLOCK_H_
|
/*
* Copyright (c) 2007-2012 by Apple Inc.. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/*
File: AvailabilityInternal.h
Contains: implementation details of __OSX_AVAILABLE_* macros from <Availability.h>
*/
#ifndef __AVAILABILITY_INTERNAL__
#define __AVAILABILITY_INTERNAL__
#ifndef __IPHONE_OS_VERSION_MIN_REQUIRED
#ifdef __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
/* compiler sets __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ when -miphoneos-version-min is used */
#define __IPHONE_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
#endif
#endif
#define __AVAILABILITY_INTERNAL_DEPRECATED __attribute__((deprecated))
#ifdef __has_feature
#if __has_feature(attribute_deprecated_with_message)
#define __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg) __attribute__((deprecated(_msg)))
#else
#define __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg) __attribute__((deprecated))
#endif
#elif defined(__GNUC__) && ((__GNUC__ >= 5) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)))
#define __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg) __attribute__((deprecated(_msg)))
#else
#define __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg) __attribute__((deprecated))
#endif
#define __AVAILABILITY_INTERNAL_UNAVAILABLE __attribute__((unavailable))
#define __AVAILABILITY_INTERNAL_WEAK_IMPORT __attribute__((weak_import))
#define __AVAILABILITY_INTERNAL_REGULAR
#ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
/* make sure a default max version is set */
#ifndef __IPHONE_OS_VERSION_MAX_ALLOWED
#define __IPHONE_OS_VERSION_MAX_ALLOWED __IPHONE_8_0
#endif
/* make sure a valid min is set */
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_0
#undef __IPHONE_OS_VERSION_MIN_REQUIRED
#define __IPHONE_OS_VERSION_MIN_REQUIRED __IPHONE_2_0
#endif
#if defined(__has_attribute) && defined(__has_feature)
#if __has_attribute(availability)
/* use better attributes if possible */
#define __AVAILABILITY_INTERNAL__IPHONE_2_0 __attribute__((availability(ios,introduced=2.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_0 __attribute__((availability(ios,introduced=2.0,deprecated=2.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1 __attribute__((availability(ios,introduced=2.0,deprecated=2.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2 __attribute__((availability(ios,introduced=2.0,deprecated=2.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=2.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0 __attribute__((availability(ios,introduced=2.0,deprecated=3.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __attribute__((availability(ios,introduced=2.0,deprecated=3.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=2.0,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=2.0,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=2.0,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=2.0,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=2.0,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=2.0,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=2.0,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=2.0,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=2.0,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=2.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=2.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=2.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=2.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=2.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_1 __attribute__((availability(ios,introduced=2.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1 __attribute__((availability(ios,introduced=2.1,deprecated=2.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=2.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=2.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2 __attribute__((availability(ios,introduced=2.1,deprecated=2.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=2.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=2.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0 __attribute__((availability(ios,introduced=2.1,deprecated=3.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __attribute__((availability(ios,introduced=2.1,deprecated=3.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=2.1,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=2.1,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=2.1,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=2.1,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=2.1,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=2.1,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=2.1,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=2.1,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=2.1,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=2.1,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=2.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=2.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=2.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=2.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_2 __attribute__((availability(ios,introduced=2.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2 __attribute__((availability(ios,introduced=2.2,deprecated=2.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=2.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=2.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0 __attribute__((availability(ios,introduced=2.2,deprecated=3.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __attribute__((availability(ios,introduced=2.2,deprecated=3.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=2.2,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=2.2,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=2.2,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=2.2,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=2.2,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=2.2,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=2.2,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=2.2,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=2.2,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=2.2,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=2.2,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=2.2,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=2.2,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_NA __attribute__((availability(ios,introduced=2.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=2.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_0 __attribute__((availability(ios,introduced=3.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0 __attribute__((availability(ios,introduced=3.0,deprecated=3.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __attribute__((availability(ios,introduced=3.0,deprecated=3.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=3.0,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=3.0,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=3.0,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=3.0,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=3.0,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=3.0,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=3.0,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=3.0,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=3.0,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=3.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=3.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=3.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=3.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=3.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_1 __attribute__((availability(ios,introduced=3.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __attribute__((availability(ios,introduced=3.1,deprecated=3.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=3.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=3.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=3.1,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=3.1,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=3.1,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=3.1,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=3.1,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=3.1,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=3.1,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=3.1,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=3.1,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=3.1,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=3.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=3.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=3.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=3.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_2 __attribute__((availability(ios,introduced=3.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __attribute__((availability(ios,introduced=3.2,deprecated=3.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=3.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=3.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=3.2,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=3.2,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=3.2,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=3.2,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=3.2,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=3.2,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=3.2,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=3.2,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=3.2,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=3.2,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=3.2,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=3.2,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_NA __attribute__((availability(ios,introduced=3.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=3.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_0 __attribute__((availability(ios,introduced=4.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __attribute__((availability(ios,introduced=4.0,deprecated=4.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=4.0,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=4.0,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=4.0,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=4.0,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=4.0,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=4.0,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=4.0,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=4.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=4.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=4.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=4.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=4.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_1 __attribute__((availability(ios,introduced=4.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __attribute__((availability(ios,introduced=4.1,deprecated=4.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=4.1,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=4.1,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=4.1,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=4.1,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=4.1,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=4.1,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=4.1,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=4.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=4.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=4.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=4.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_2 __attribute__((availability(ios,introduced=4.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __attribute__((availability(ios,introduced=4.2,deprecated=4.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=4.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=4.2)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=4.2,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=4.2,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=4.2,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=4.2,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=4.2,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=4.2,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=4.2,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=4.2,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.2,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_NA __attribute__((availability(ios,introduced=4.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=4.2)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_3 __attribute__((availability(ios,introduced=4.3)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __attribute__((availability(ios,introduced=4.3,deprecated=4.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=4.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=4.3)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=4.3,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=4.3,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=4.3,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=4.3,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=4.3,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=4.3,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=4.3,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=4.3,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_NA __attribute__((availability(ios,introduced=4.3)))
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=4.3)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_0 __attribute__((availability(ios,introduced=5.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __attribute__((availability(ios,introduced=5.0,deprecated=5.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=5.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=5.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=5.0,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=5.0,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=5.0,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=5.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=5.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=5.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=5.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=5.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=5.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_1 __attribute__((availability(ios,introduced=5.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __attribute__((availability(ios,introduced=5.1,deprecated=5.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=5.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=5.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=5.1,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=5.1,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=5.1,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=5.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=5.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=5.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=5.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=5.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_0 __attribute__((availability(ios,introduced=6.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __attribute__((availability(ios,introduced=6.0,deprecated=6.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=6.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=6.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=6.0,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=6.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=6.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=6.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=6.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=6.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=6.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_1 __attribute__((availability(ios,introduced=6.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __attribute__((availability(ios,introduced=6.1,deprecated=6.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=6.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=6.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=6.1,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=6.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=6.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=6.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=6.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=6.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_0 __attribute__((availability(ios,introduced=7.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __attribute__((availability(ios,introduced=7.0,deprecated=7.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=7.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=7.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=7.0,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=7.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=7.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=7.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=7.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_1 __attribute__((availability(ios,introduced=7.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __attribute__((availability(ios,introduced=7.1,deprecated=7.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=7.1,deprecated=7.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __attribute__((availability(ios,introduced=7.1,deprecated=7.1)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=7.1,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=7.1,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=7.1,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_NA __attribute__((availability(ios,introduced=7.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=7.1)))
#define __AVAILABILITY_INTERNAL__IPHONE_8_0 __attribute__((availability(ios,introduced=8.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __attribute__((availability(ios,introduced=8.0,deprecated=8.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=8.0,deprecated=8.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __attribute__((availability(ios,introduced=8.0,deprecated=8.0)))
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_NA __attribute__((availability(ios,introduced=8.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,introduced=8.0)))
#define __AVAILABILITY_INTERNAL__IPHONE_NA __attribute__((availability(ios,unavailable)))
#define __AVAILABILITY_INTERNAL__IPHONE_NA_DEP__IPHONE_NA __attribute__((availability(ios,unavailable)))
#define __AVAILABILITY_INTERNAL__IPHONE_NA_DEP__IPHONE_NA_MSG(_msg) __attribute__((availability(ios,unavailable)))
#endif
#endif
#ifndef __AVAILABILITY_INTERNAL__IPHONE_2_0
/* set up old style internal macros (up to 2.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_2_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_2_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
/* set up old style internal macros (up to 2.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 2.2) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_2 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_2_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 3.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 3.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 3.2) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_3_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 4.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 4.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 4.2) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 4.3) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_4_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 5.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 5.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_5_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 6.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 6.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_6_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 7.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 7.1) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_1
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL__IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_1
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_7_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up old style internal macros (up to 8.0) */
#if __IPHONE_OS_VERSION_MAX_ALLOWED < __IPHONE_8_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_8_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_NA __AVAILABILITY_INTERNAL__IPHONE_8_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_8_0
#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_2_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_2_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_3_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_3_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_2
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_2
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_4_3
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_4_3
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_5_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_5_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_6_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_6_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_7_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_0
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_7_1
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_7_1
#elif __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_8_0
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_REGULAR
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL__IPHONE_8_0
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL__IPHONE_8_0
#else
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_2_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_3_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_2_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_4_3_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_5_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_6_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_7_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_7_1_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__IPHONE_8_0_DEP__IPHONE_8_0_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#endif
/* set up internal macros (n/a) */
#define __AVAILABILITY_INTERNAL__IPHONE_NA __AVAILABILITY_INTERNAL_UNAVAILABLE
#define __AVAILABILITY_INTERNAL__IPHONE_NA_DEP__IPHONE_NA __AVAILABILITY_INTERNAL_UNAVAILABLE
#define __AVAILABILITY_INTERNAL__IPHONE_NA_DEP__IPHONE_NA_MSG(_msg) __AVAILABILITY_INTERNAL_UNAVAILABLE
#endif
#elif defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
/* compiler for Mac OS X sets __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ */
#define __MAC_OS_X_VERSION_MIN_REQUIRED __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
/* make sure a default max version is set */
#ifndef __MAC_OS_X_VERSION_MAX_ALLOWED
#define __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_10_10
#endif
#if defined(__has_attribute) && defined(__has_feature)
#if __has_attribute(availability)
/* use better attributes if possible */
#define __AVAILABILITY_INTERNAL__MAC_10_0 __attribute__((availability(macosx,introduced=10.0)))
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0 __attribute__((availability(macosx,introduced=10.0,deprecated=10.0)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.0,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_0_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.0)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1 __attribute__((availability(macosx,introduced=10.0,deprecated=10.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.1)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2 __attribute__((availability(macosx,introduced=10.0,deprecated=10.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.2)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3 __attribute__((availability(macosx,introduced=10.0,deprecated=10.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.3)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4 __attribute__((availability(macosx,introduced=10.0,deprecated=10.4)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.4,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.4)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.0,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.0,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.0,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.0,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.0,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.0,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.0)))
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.0)))
#define __AVAILABILITY_INTERNAL__MAC_10_1 __attribute__((availability(macosx,introduced=10.1)))
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1 __attribute__((availability(macosx,introduced=10.1,deprecated=10.1)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.1,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.1)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2 __attribute__((availability(macosx,introduced=10.1,deprecated=10.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.2)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3 __attribute__((availability(macosx,introduced=10.1,deprecated=10.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.3)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4 __attribute__((availability(macosx,introduced=10.1,deprecated=10.4)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.4,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.4)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.1,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.1,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.1,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.1,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.1,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.1,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.1,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.1)))
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.1)))
#define __AVAILABILITY_INTERNAL__MAC_10_2 __attribute__((availability(macosx,introduced=10.2)))
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2 __attribute__((availability(macosx,introduced=10.2,deprecated=10.2)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.2,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.2)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3 __attribute__((availability(macosx,introduced=10.2,deprecated=10.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.3)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4 __attribute__((availability(macosx,introduced=10.2,deprecated=10.4)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.4)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.2,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.2,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.2,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.2,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.2,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.2,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.2,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.2)))
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.2)))
#define __AVAILABILITY_INTERNAL__MAC_10_3 __attribute__((availability(macosx,introduced=10.3)))
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3 __attribute__((availability(macosx,introduced=10.3,deprecated=10.3)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.3,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.3)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4 __attribute__((availability(macosx,introduced=10.3,deprecated=10.4)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.4,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.4)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.3,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.3,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.3,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.3,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.3,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.3,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.3,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.3)))
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.3)))
#define __AVAILABILITY_INTERNAL__MAC_10_4 __attribute__((availability(macosx,introduced=10.4)))
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4 __attribute__((availability(macosx,introduced=10.4,deprecated=10.4)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.4,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.4)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.4,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.4,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.4,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.4,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.4,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.4,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.4,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.4)))
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.4)))
#define __AVAILABILITY_INTERNAL__MAC_10_5 __attribute__((availability(macosx,introduced=10.5)))
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5 __attribute__((availability(macosx,introduced=10.5,deprecated=10.5)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.5,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.5)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.5,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.5,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.5,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.5,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.5,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.5,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.5)))
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.5)))
#define __AVAILABILITY_INTERNAL__MAC_10_6 __attribute__((availability(macosx,introduced=10.6)))
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6 __attribute__((availability(macosx,introduced=10.6,deprecated=10.6)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.6,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.6)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.6,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.6,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.6,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.6,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.6,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.6)))
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.6)))
#define __AVAILABILITY_INTERNAL__MAC_10_7 __attribute__((availability(macosx,introduced=10.7)))
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7 __attribute__((availability(macosx,introduced=10.7,deprecated=10.7)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.7,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.7)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.7,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.7,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.7,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.7,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.7)))
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.7)))
#define __AVAILABILITY_INTERNAL__MAC_10_8 __attribute__((availability(macosx,introduced=10.8)))
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8 __attribute__((availability(macosx,introduced=10.8,deprecated=10.8)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.8,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.8)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.8,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.8,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.8,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.8)))
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.8)))
#define __AVAILABILITY_INTERNAL__MAC_10_9 __attribute__((availability(macosx,introduced=10.9)))
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9 __attribute__((availability(macosx,introduced=10.9,deprecated=10.9)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.9,deprecated=10.9,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9_MSG(_msg) __attribute__((availability(macosx,introduced=10.9,deprecated=10.9)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.9,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.9,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.9,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.9)))
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.9)))
#define __AVAILABILITY_INTERNAL__MAC_10_10 __attribute__((availability(macosx,introduced=10.10)))
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10 __attribute__((availability(macosx,introduced=10.10,deprecated=10.10)))
#if __has_feature(attribute_availability_with_message)
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.10,deprecated=10.10,message=_msg)))
#else
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10_MSG(_msg) __attribute__((availability(macosx,introduced=10.10,deprecated=10.10)))
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,introduced=10.10)))
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_NA __attribute__((availability(macosx,introduced=10.10)))
#define __AVAILABILITY_INTERNAL__MAC_NA __attribute__((availability(macosx,unavailable)))
#define __AVAILABILITY_INTERNAL__MAC_NA_DEP__MAC_NA __attribute__((availability(macosx,unavailable)))
#define __AVAILABILITY_INTERNAL__MAC_NA_DEP__MAC_NA_MSG(_msg) __attribute__((availability(macosx,unavailable)))
#endif
#endif
#ifndef __AVAILABILITY_INTERNAL__MAC_10_0
/* use old style attributes */
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_10 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_10 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_10 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_9 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_8 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_7 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_6 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_5 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_4 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_3 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_2 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_1 __AVAILABILITY_INTERNAL_REGULAR
#endif
#if __MAC_OS_X_VERSION_MAX_ALLOWED < __MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0 __AVAILABILITY_INTERNAL_UNAVAILABLE
#elif __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0 __AVAILABILITY_INTERNAL_WEAK_IMPORT
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0 __AVAILABILITY_INTERNAL_REGULAR
#endif
#define __AVAILABILITY_INTERNAL__MAC_NA __AVAILABILITY_INTERNAL_UNAVAILABLE
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_1_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_1_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_2_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_3_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_4_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_5_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6 __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_6_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7 __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_7_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_7
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8 __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_8_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_8
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9 __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_9_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_9
#endif
#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10 __AVAILABILITY_INTERNAL_DEPRECATED
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL_DEPRECATED_MSG(_msg)
#else
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10 __AVAILABILITY_INTERNAL__MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_10_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_10
#endif
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_0_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_0
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_1_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_1
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_2
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_3
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_4
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_5
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_6
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_7
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_8
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_9
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_NA __AVAILABILITY_INTERNAL__MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL__MAC_10_10
#define __AVAILABILITY_INTERNAL__MAC_NA_DEP__MAC_NA __AVAILABILITY_INTERNAL_UNAVAILABLE
#define __AVAILABILITY_INTERNAL__MAC_NA_DEP__MAC_NA_MSG(_msg) __AVAILABILITY_INTERNAL_UNAVAILABLE
#endif
#endif
#endif /* __AVAILABILITY_INTERNAL__ */
|
/**
@file db_mysql.h
@date 2019/06/03
@author FINL Chain Team
@version
@brief
*/
#ifndef __DB_MYSQL_H__
#define __DB_MYSQL_H__
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct {
MYSQL conn;
MYSQL conn_db; // block
} MYSQL_INST_T;
//
extern void mysql_get_svr_version(void);
extern void mysql_get_cli_version(void);
//
extern DB_RESULT_E mysql_conn_init(void **pp_mgr, uint16_t mgr_cnt, char *p_db_host, uint16_t db_port, char *p_db_user, char *p_db_pw, char *p_db_name, char *p_db_sock, char *p_pw_path, char *p_seed_path);
extern void mysql_conn_close(void **pp_mgr);
extern DB_RESULT_E mysql_truncate(void);
// Insert Table - block DB
extern DB_RESULT_E mysql_insert_t_blk_tx(uint64_t blk_num, uint64_t db_key, uint8_t *p_sc_hash);
extern void *mysql_insert_t_blk_tx_start(uint32_t len);
extern DB_RESULT_E mysql_insert_t_blk_tx_process(void *p_arg, bool b_last, uint64_t blk_num, uint64_t db_key, uint8_t *p_sc_hash);
extern DB_RESULT_E mysql_insert_t_blk_tx_end(void *p_arg);
extern DB_RESULT_E mysql_insert_t_blk_contents(CONS_LIGHT_BLK_T *p_light_blk);
// Update Table - block DB
extern DB_RESULT_E mysql_update_bct_t_blk_contents_w_bn(uint64_t blk_num, uint64_t bct);
extern DB_RESULT_E mysql_update_bn_t_blk_txs_w_bn0(uint64_t blk_num);
// Select - block DB
extern DB_RESULT_E mysql_select_xor_txs_f_blk_txs_w_bn(DB_TX_FIELD_T *p_db_tx);
extern uint32_t mysql_select_count_f_blk_txs_w_bn(uint64_t blk_num);
extern DB_RESULT_E mysql_select_hash_f_blk_txs_w_dk(uint64_t db_key, uint8_t *p_tx_hash);
extern uint64_t mysql_select_db_key_f_blk_txs_w_bn(uint64_t blk_num, bool min_v);
extern DB_RESULT_E mysql_select_blk_f_blk_contents_w_bn(uint64_t blk_num, CONS_LIGHT_BLK_T *p_light_blk);
extern DB_RESULT_E mysql_select_hash_f_blk_contents_w_bn(uint64_t blk_num, uint8_t *p_blk_hash);
extern uint64_t mysql_select_last_bn_f_blk_contents(void);
extern uint64_t mysql_select_bct_f_blk_contents_w_bn(uint64_t blk_num);
#ifdef __cplusplus
}
#endif
#endif /* __DB_MYSQL_H__ */
|
#ifndef DATASETOBJECT_H
#define DATASETOBJECT_H
#include <TSqlObject>
#include <QSharedData>
class T_MODEL_EXPORT DatasetObject : public TSqlObject, public QSharedData
{
public:
int image_width {0};
int image_height {0};
QString mean_file;
QString label_file;
QString train_db_path;
QString val_db_path;
QString log_file;
int num_classes {0};
int num_train_image {0};
int num_val_image {0};
QString name_size_file;
QString label_map_file;
enum PropertyIndex {
ImageWidth = 0,
ImageHeight,
MeanFile,
LabelFile,
TrainDbPath,
ValDbPath,
LogFile,
NumClasses,
NumTrainImage,
NumValImage,
NameSizeFile,
LabelMapFile,
};
int primaryKeyIndex() const override { return -1; }
int autoValueIndex() const override { return -1; }
QString tableName() const override { return QLatin1String("dataset"); }
private: /*** Don't modify below this line ***/
Q_OBJECT
Q_PROPERTY(int image_width READ getimage_width WRITE setimage_width)
T_DEFINE_PROPERTY(int, image_width)
Q_PROPERTY(int image_height READ getimage_height WRITE setimage_height)
T_DEFINE_PROPERTY(int, image_height)
Q_PROPERTY(QString mean_file READ getmean_file WRITE setmean_file)
T_DEFINE_PROPERTY(QString, mean_file)
Q_PROPERTY(QString label_file READ getlabel_file WRITE setlabel_file)
T_DEFINE_PROPERTY(QString, label_file)
Q_PROPERTY(QString train_db_path READ gettrain_db_path WRITE settrain_db_path)
T_DEFINE_PROPERTY(QString, train_db_path)
Q_PROPERTY(QString val_db_path READ getval_db_path WRITE setval_db_path)
T_DEFINE_PROPERTY(QString, val_db_path)
Q_PROPERTY(QString log_file READ getlog_file WRITE setlog_file)
T_DEFINE_PROPERTY(QString, log_file)
Q_PROPERTY(int num_classes READ getnum_classes WRITE setnum_classes)
T_DEFINE_PROPERTY(int, num_classes)
Q_PROPERTY(int num_train_image READ getnum_train_image WRITE setnum_train_image)
T_DEFINE_PROPERTY(int, num_train_image)
Q_PROPERTY(int num_val_image READ getnum_val_image WRITE setnum_val_image)
T_DEFINE_PROPERTY(int, num_val_image)
Q_PROPERTY(QString name_size_file READ getname_size_file WRITE setname_size_file)
T_DEFINE_PROPERTY(QString, name_size_file)
Q_PROPERTY(QString label_map_file READ getlabel_map_file WRITE setlabel_map_file)
T_DEFINE_PROPERTY(QString, label_map_file)
};
#endif // DATASETOBJECT_H
|
/*******************************************************************************
* - FILE: workerer.c
* - DESC: WORKER_THREAD object.
*******************************************************************************/
/* imports */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>
/* local imports */
#include "structs.h"
#include "../utilities/_utilities.h"
#include "_objects.h"
/* header */
#include "worker.h"
/* constructor */
WORKER_THREAD*
WORKER_THREAD_Create() {
WORKER_THREAD* worker = NULL;
worker = (WORKER_THREAD*)ERROR_malloc(sizeof(WORKER_THREAD));
return worker;
}
/* destructor */
void* WORKER_THREAD_Destroy(WORKER_THREAD* worker) {
ERROR_free(worker);
return NULL;
}
|
#include "stm32f4xx.h"
#include "delay.h"
#include "rtc.h"
#define delay_ms(delay) Delay_ms(delay)
void Rtc_Init() {
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
PWR_BackupAccessCmd(ENABLE);
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
RCC_RTCCLKCmd(ENABLE);
delay_ms(50);
RTC_InitTypeDef RTC_InitStruct = {
.RTC_HourFormat=RTC_HourFormat_24,
.RTC_AsynchPrediv=0x7F,
.RTC_SynchPrediv=0xFF,
};
RTC_Init(&RTC_InitStruct);
}
void Rtc_SetDate(u8 year, u8 month, u8 date, u8 weekDay) {
RTC_DateTypeDef RTC_DataStruct = {
.RTC_Year=year,
.RTC_Month=month,
.RTC_Date=date,
.RTC_WeekDay=weekDay,
};
RTC_SetDate(RTC_Format_BIN, &RTC_DataStruct);
}
void Rtc_SetTime(u8 hours, u8 minutes, u8 seconds) {
RTC_TimeTypeDef RTC_TimeStruct = {
.RTC_H12=(hours >= 12) ? (RTC_H12_PM) : (RTC_H12_AM),
.RTC_Hours=hours,
.RTC_Minutes=minutes,
.RTC_Seconds=seconds,
};
RTC_SetTime(RTC_Format_BIN, &RTC_TimeStruct);
}
#undef delay_ms
|
Subsets and Splits