{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy\n",
    "from scipy.stats import ttest_ind, binom_test, spearmanr\n",
    "from statsmodels.stats.proportion import proportions_ztest\n",
    "import matplotlib as mpl\n",
    "\n",
    "\n",
    "\n",
    "scipy.__version__\n"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'1.6.3'"
      ]
     },
     "metadata": {},
     "execution_count": 2
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "#Load the data\n",
    "\n",
    "raw_coded_data = pd.read_csv('/Users/madelineendres/Documents/Research/Weed/Survey Analysis/Data/CodedData.csv')\n",
    "raw_cat_data = pd.read_csv('/Users/madelineendres/Documents/Research/Weed/Survey Analysis/Data/CategoricalData.csv')\n",
    "num_data = raw_coded_data[raw_coded_data['IsValid'] == True] \n",
    "cat_data = raw_cat_data[raw_cat_data['IsValid'] == True]\n",
    "num_data.shape, cat_data.shape"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "((803, 376), (803, 444))"
      ]
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Survey Response Rates"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "# Calculate response rates\n",
    "\n",
    "print(\"Total number of survey starts: {}\".format(len(raw_cat_data)))\n",
    "print(\"Total number of completed surveys: {}\".format(len(raw_cat_data[raw_cat_data['Progress']==100])))\n",
    "print(\"Total number of complete and valid surveys: {}\".format(len(num_data)))\n",
    "print(\"Survey completion rate: {:.2f}%\".format(len(num_data) / len(raw_cat_data) * 100))\n",
    "\n",
    "ugrad_student_emails_sent = 5638\n",
    "ugrad_student_emails_bounced = 12\n",
    "ugrad_student_survey_responses = len(num_data[num_data['version'] == 'ap56'])\n",
    "print(\"\\nNumber of undergrad responses: {}\".format(ugrad_student_survey_responses))\n",
    "print(\"Undergrad response rate: {:.2f}%\".format(ugrad_student_survey_responses / (ugrad_student_emails_sent - ugrad_student_emails_bounced)* 100))\n",
    "\n",
    "github_emails_sent = 5759\n",
    "github_emails_bounced = 36\n",
    "non_github_options = ['ap56', 'tp44', 'gs23', 'wrg']\n",
    "github_email_responses = len(num_data) - len(num_data[num_data['version'].isin(non_github_options)])\n",
    "print(\"\\nNumber of github responses: {}\".format(github_email_responses))\n",
    "print(\"Github response rate: {:.2f}%\".format(github_email_responses / (github_emails_sent - github_emails_bounced)* 100))\n",
    "\n",
    "print(\"\\nOther responses (grad students, twitter): {}\".format(len(num_data) - github_email_responses - ugrad_student_survey_responses))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Total number of survey starts: 1045\n",
      "Total number of completed surveys: 809\n",
      "Total number of complete and valid surveys: 803\n",
      "Survey completion rate: 76.84%\n",
      "\n",
      "Number of undergrad responses: 283\n",
      "Undergrad response rate: 5.03%\n",
      "\n",
      "Number of github responses: 440\n",
      "Github response rate: 7.69%\n",
      "\n",
      "Other responses (grad students, twitter): 80\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Helper Functions"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "# Now here, mark all of the groups that I am going to need\n",
    "\n",
    "# Recruitment groups\n",
    "umich_options = ['ap56', 'gs23', 'wrg']\n",
    "umich_responses = num_data[num_data['version'].isin(umich_options)]\n",
    "umich_responses_cat = cat_data[cat_data['version'].isin(umich_options)]\n",
    "social_media_responses = num_data[num_data['version'] == 'tp44']\n",
    "social_media_responses_cat = cat_data[cat_data['version'] == 'tp44']\n",
    "non_github_options = ['ap56', 'tp44', 'gs23', 'wrg']\n",
    "git_responses = num_data[~num_data['version'].isin(non_github_options)]\n",
    "git_responses_cat = cat_data[~cat_data['version'].isin(non_github_options)]\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "source": [
    "# And some additional functions for statistical tests\n",
    "def summary_statistics(group1, group2):\n",
    "    print(\"Number of {}: {}, Number of {}: {}\".format(group1[0], sum(group1[1].value_counts()), group2[0], sum(group2[1].value_counts())))\n",
    "    print(\"Mean of {}: {:.3f}, Mean of {}: {:.3f}\".format(group1[0], group1[1].mean(skipna=True), group2[0], group2[1].mean(skipna=True)))\n",
    "    print(\"Median of {}: {:.3f}, Median of {}: {:.3f}\".format(group1[0], group1[1].median(), group2[0], group2[1].median()))\n",
    "    print(\"Stdev of {}: {:.3f}, Stdev of {}: {:.3f}\".format(group1[0], group1[1].std(), group2[0], group2[1].std()))\n",
    "\n",
    "def print_t_test_result(test):\n",
    "    if len(test) == 2:\n",
    "        print(\"Test type: {}, p = {:.3e}, stat = {:.3f}\\n\".format(str(type(test)), test[1], test[0]))\n",
    "    else:\n",
    "        print(\"Test type: {}, p = {:.3e}\\n\".format(str(type(test)), test))\n",
    "\n",
    "def catch(func, handle=lambda e : e, *args, **kwargs):\n",
    "    try:\n",
    "        return func(*args, **kwargs)\n",
    "    except Exception as e:\n",
    "        return handle(e)\n",
    "\n",
    "def print_latex(in_table, has_percents=False):\n",
    "    # source: https://stackoverflow.com/questions/3685195/line-up-columns-of-numbers-print-output-in-table-format\n",
    "    if has_percents:\n",
    "        for r in range(len(in_table)):\n",
    "            for c in range(1, len(in_table[r])):\n",
    "                in_table[r][c] = str(in_table[r][c][0]) + ' (' + str(round(in_table[r][c][0] / in_table[r][c][1] * 100, 1)) + '%)'\n",
    "\n",
    "    # Split input data by row and then on spaces\n",
    "    rows = [ '\\t'.join([str(item) for item in row]).split('\\t') for row in in_table ]\n",
    "\n",
    "    # Reorganize data by columns\n",
    "    cols = zip(*rows)\n",
    "\n",
    "    # Compute column widths by taking maximum length of values per column\n",
    "    col_widths = [ max(len(value) for value in col) for col in cols ]\n",
    "\n",
    "    # Create a suitable format string\n",
    "    format = ' '.join(['%%%ds ' % width for width in col_widths ])\n",
    "\n",
    "    # Print each row using the computed format\n",
    "    for row in rows:\n",
    "        print(format % tuple(row))\n",
    "\n",
    "def benjamini_hochberg(p_values, q_threshold):\n",
    "    \"\"\"\n",
    "    # Correct for multpile comparisons - Benjamini–Hochberg (https://www.statisticshowto.com/benjamini-hochberg-procedure/)\n",
    "    \"\"\"\n",
    "    # First sort the p_values from small to big\n",
    "    \n",
    "    sorted_p_vals = sorted(p_values)\n",
    "    result = []\n",
    "    for rank in range(1, len(p_values) + 1):\n",
    "        critical_value = (rank / len(p_values)) * q_threshold\n",
    "        passed = True if sorted_p_vals[rank - 1] <= critical_value else False\n",
    "        result.append((sorted_p_vals[rank - 1], rank, critical_value, passed))\n",
    "    return result\n",
    "\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Survey Demographics"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "\n",
    "# Generte Gender Table\n",
    "genders = { 'Man': ['Male', 'Transgender Male'], \n",
    "            'Woman':['Female', 'Transgender Female'], \n",
    "            'Non-binary':['Gender Variant/Non-Conforming', 'Not Listed'], \n",
    "            'No Answer':['Prefer Not to Answer']}\n",
    "\n",
    "cat_values = [cat_data, git_responses_cat, umich_responses_cat, social_media_responses_cat]\n",
    "num_values = [num_data, git_responses, umich_responses, social_media_responses]\n",
    "\n",
    "latex_table = []\n",
    "for k, o in genders.items():\n",
    "    current_row = [k]\n",
    "    for v in cat_values:\n",
    "        current_val_counts = v['Q1.2'].value_counts()\n",
    "        overall_total = sum(current_val_counts)\n",
    "        current_row.append((sum(catch(lambda : current_val_counts[g], handle=lambda e : 0) for g in o),overall_total))\n",
    "    latex_table.append(current_row)\n",
    "\n",
    "print_latex(latex_table, has_percents=True)\n",
    "\n",
    "#  Generate Age Table\n",
    "latex_table = []\n",
    "age_stats = {\n",
    "    'Median age': ['50%'],\n",
    "    'Average age': ['mean'],\n",
    "    'Minimum age': ['min'],\n",
    "    'Maximum age': ['max']\n",
    "}\n",
    "\n",
    "for k, o in age_stats.items():\n",
    "    current_row = [k]\n",
    "    for v in num_values:\n",
    "        current_val_counts = v[v['Q1.3']!= -99]['Q1.3'].describe()\n",
    "        overall_total = sum(current_val_counts)\n",
    "        current_row.append(round(sum(catch(lambda : current_val_counts[g], handle=lambda e : 0) for g in o), 1))\n",
    "    latex_table.append(current_row)\n",
    "print_latex(latex_table, has_percents=False)\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "       Man  666 (82.9%)  403 (91.6%)  243 (71.7%)  20 (83.3%) \n",
      "     Woman  112 (13.9%)    21 (4.8%)   87 (25.7%)   4 (16.7%) \n",
      "Non-binary    20 (2.5%)    12 (2.7%)     8 (2.4%)    0 (0.0%) \n",
      " No Answer     5 (0.6%)     4 (0.9%)     1 (0.3%)    0 (0.0%) \n",
      " Median age  26.0  34.0  21.0  29.0 \n",
      "Average age  29.2  34.9  21.7  31.0 \n",
      "Minimum age  15.0  15.0  18.0  21.0 \n",
      "Maximum age  70.0  70.0  61.0  52.0 \n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "# Demographics: Employment status\n",
    "num_values = [num_data, git_responses, umich_responses, social_media_responses]\n",
    "\n",
    "# print number of students:\n",
    "print('\\nnumber of students', end='  ')\n",
    "for df in num_values:\n",
    "    print('{} '.format(df['Q1.5_3'].value_counts()[1]), end='  ')\n",
    "\n",
    "# print number currently employed in a programming related job full time\n",
    "print('\\nfull-time prog employ', end='  ')\n",
    "for df in num_values:\n",
    "    print('{} '.format(df[df['Q2.14'] == 1]['Q1.5_4'].value_counts()[1]), end='  ')\n",
    "\n",
    "# print number currently employed full time\n",
    "print('\\nfull-time employee', end='  ')\n",
    "for df in num_values:\n",
    "    print('{} '.format(df['Q1.5_4'].value_counts()[1]), end='  ')\n",
    "\n",
    "# print number currently employed in a programming related job part time\n",
    "print('\\npart-time prog employ', end='  ')\n",
    "for df in num_values:\n",
    "    print('{} '.format(df[df['Q2.14'] == 1]['Q1.5_5'].value_counts()[1]), end='  ')\n",
    "\n",
    "# print number currently employed in a programming related job full stop\n",
    "print()\n",
    "for df in num_values:\n",
    "    print('{} '.format(df['Q2.14'].value_counts()[1]), end='  ')\n",
    "\n",
    "# Now job titles:\n",
    "print('\\nSystems engineer', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_14'] == 1)])), end='  ')\n",
    "\n",
    "\n",
    "print('\\nCS Instructor', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_1'] == 1)])), end='  ')\n",
    "\n",
    "print('\\nCS Researcher', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_2'] == 1)])), end='  ')\n",
    "\n",
    "print('\\nSoftware Engineer', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_13'] == 1)])), end='  ')\n",
    "\n",
    "print('\\nProduct Manager', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_9'] == 1)])), end='  ')\n",
    "\n",
    "print('\\nIT', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[\n",
    "                            (df['Q2.15_7'] == 1)])), end='  ')\n",
    "    \n",
    "\n",
    "print('\\nProgrammer, Developer', end='  ')\n",
    "# Answered yes to Freelance Developer, Front End Developer, Open Source Developer, Software Developer / Programmer,  web developer\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[(df['Q2.15_5'] == 1)| # Freelance Developer\n",
    "                            (df['Q2.15_6'] == 1)| # Front End Developer\n",
    "                            (df['Q2.15_8'] == 1)| # Open Source Developer\n",
    "                            (df['Q2.15_12'] == 1)| # Software Developer / Programmer\n",
    "                            (df['Q2.15_15'] == 1)])), end='  ') # web developer\n",
    "\n",
    "print('\\nData', end='  ')\n",
    "\n",
    "# Answered yes to Freelance Developer, Front End Developer, Open Source Developer, Software Developer / Programmer, Software Engineer, web developer\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[(df['Q2.15_3'] == 1)| # Freelance Developer\n",
    "                            (df['Q2.15_4'] == 1)])), end='  ') # web develope\n",
    "\n",
    "\n",
    "\n",
    "print('\\nUnemployed', end='  ')\n",
    "for df in num_values:\n",
    "\n",
    "    print('{} '.format(len(df[(df['Q1.5_1'] == 1)| # Freelance Developer\n",
    "                            (df['Q1.5_2'] == 1)])), end='  ') # web developer                            "
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n",
      "number of students  290   34   251   5   \n",
      "full-time prog employ  450   358   75   17   \n",
      "full-time employee  464   364   83   17   \n",
      "part-time prog employ  50   18   30   2   \n",
      "576   406   149   21   \n",
      "Systems engineer  72   54   15   3   \n",
      "CS Instructor  49   29   20   0   \n",
      "CS Researcher  53   23   25   5   \n",
      "Software Engineer  311   232   70   9   \n",
      "Product Manager  22   17   4   1   \n",
      "IT  21   16   5   0   \n",
      "Programmer, Developer  270   190   70   10   \n",
      "Data  49   25   24   0   \n",
      "Unemployed  54   19   34   1   "
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# RQ1: Cannabis usage while programming\n",
    "\n",
    "What percent of my sample has used cannabis, and what percentage has used it while programming, and how often do they use it.\n",
    "\n",
    "The main survey questions being analyzed here are:\n",
    "* 5.01: General Cannabis use \n",
    "* 6.01: General Cannabis use while programming\n",
    "* 6.03: Frequency of cannabis use while programming in the last year\n",
    "\n",
    "For the frequency question, the answer choices correspond as follows:\n",
    "* 0: I do not use cannabis\n",
    "* 1: less than once a year\n",
    "* 2: once a year\n",
    "* 3: once every 3-6 months (2-4 times/yr)\n",
    "* 4: once every 2 months (6 times/yr)\n",
    "* 5: once a month (12 times/yr)\n",
    "* 6: 2 – 3 times a month\n",
    "* 7: once a week\n",
    "* 8: twice a week\n",
    "* 9: 3 – 4 times a week\n",
    "* 10: 5 – 6 times a week\n",
    "* 11: once a day\n",
    "* 12: more than once a day\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "def print_population_details(population_name, population_df):\n",
    "    print(\"Percent of {} who have tried cannabis: {:.2f}% ({})\".format(population_name, len(population_df[population_df['Q5.1']==1]) / len(population_df) * 100, len(population_df[population_df['Q5.1']==1])))\n",
    "    print(\"Percent of {} who have tried cannabis while programming: {:.2f}% ({})\".format(population_name, len(population_df[population_df['Q6.01']==1]) / len(population_df) * 100, len(population_df[population_df['Q6.01']==1])))\n",
    "    print(\"Average/Median use frequency of {} who have tried cannabis: {:.2f} {} ({})\".format(population_name, population_df[(population_df['Q5.3'] >= 0)]['Q5.3'].mean(), population_df[(population_df['Q5.3'] >= 0)]['Q5.3'].median(), len(population_df[(population_df['Q5.3'] >= 0)]['Q5.3'])))\n",
    "    print(\"Average/Median use frequency of {} who have tried cannabis in last year: {:.2f} {} ({})\".format(population_name, population_df[(population_df['Q5.3'] > 1)]['Q5.3'].mean(), population_df[(population_df['Q5.3'] > 1)]['Q5.3'].median(), len(population_df[(population_df['Q5.3'] > 1)]['Q5.3'])))\n",
    "    print(\"Average/Median use frequency of {} who have tried cannabis while programming: {:.2f} {} ({})\".format(population_name, population_df[(population_df['Q6.03'] >= 0)]['Q6.03'].mean(), population_df[(population_df['Q6.03'] >= 0)]['Q6.03'].median(), len(population_df[(population_df['Q6.03'] >= 0)]['Q6.03'])))\n",
    "    print(\"Average/Median use frequency of {} who have tried cannabis while programming in last year: {:.2f} {} ({})\\n\".format(population_name, population_df[(population_df['Q6.03'] > 1)]['Q6.03'].mean(), population_df[(population_df['Q6.03'] > 1)]['Q6.03'].median(), len(population_df[(population_df['Q6.03'] > 1)]['Q6.03'])))\n",
    "\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "print(\"First let's look at percent usage of weed and percent usage of weed while programming by recruitment group:\\n\")\n",
    "\n",
    "print_population_details(\"all participants\", num_data)\n",
    "print_population_details(\"umich participants\", umich_responses)\n",
    "print_population_details(\"GitHub participants\", git_responses)\n",
    "\n",
    "print(\"Are github or university participants more likely to have tried cannabis??\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([314, 221]) # Number of users\n",
    "n_obs = np.array([440, 339]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n",
    "\n",
    "print(\"Are github or university participants more likely to have tried cannabis while programming?\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([170, 94]) # Number of users\n",
    "n_obs = np.array([440, 339]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "First let's look at percent usage of weed and percent usage of weed while programming by recruitment group:\n",
      "\n",
      "Percent of all participants who have tried cannabis: 69.36% (557)\n",
      "Percent of all participants who have tried cannabis while programming: 34.87% (280)\n",
      "Average/Median use frequency of all participants who have tried cannabis: 5.70 6.0 (556)\n",
      "Average/Median use frequency of all participants who have tried cannabis in last year: 7.44 8.0 (421)\n",
      "Average/Median use frequency of all participants who have tried cannabis while programming: 4.65 5.0 (280)\n",
      "Average/Median use frequency of all participants who have tried cannabis while programming in last year: 6.74 6.0 (188)\n",
      "\n",
      "Percent of umich participants who have tried cannabis: 65.19% (221)\n",
      "Percent of umich participants who have tried cannabis while programming: 27.73% (94)\n",
      "Average/Median use frequency of umich participants who have tried cannabis: 5.88 6.0 (221)\n",
      "Average/Median use frequency of umich participants who have tried cannabis in last year: 7.07 7.0 (182)\n",
      "Average/Median use frequency of umich participants who have tried cannabis while programming: 4.23 4.5 (94)\n",
      "Average/Median use frequency of umich participants who have tried cannabis while programming in last year: 5.87 5.0 (67)\n",
      "\n",
      "Percent of GitHub participants who have tried cannabis: 71.36% (314)\n",
      "Percent of GitHub participants who have tried cannabis while programming: 38.64% (170)\n",
      "Average/Median use frequency of GitHub participants who have tried cannabis: 5.49 5.0 (313)\n",
      "Average/Median use frequency of GitHub participants who have tried cannabis in last year: 7.69 8.0 (220)\n",
      "Average/Median use frequency of GitHub participants who have tried cannabis while programming: 4.87 5.0 (170)\n",
      "Average/Median use frequency of GitHub participants who have tried cannabis while programming in last year: 7.24 7.0 (111)\n",
      "\n",
      "Are github or university participants more likely to have tried cannabis??\n",
      "Test type: <class 'tuple'>, p = 6.557e-02, stat = 1.841\n",
      "\n",
      "Are github or university participants more likely to have tried cannabis while programming?\n",
      "Test type: <class 'tuple'>, p = 1.429e-03, stat = 3.189\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "print(\"And let's investigate the frequency of how much they currently use cannabis\")\n",
    "print(\"percent who used cannabis in last year while programming\", (280 - num_data['Q6.02'].value_counts()[1])/280*100)\n",
    "print(\"have used regularily\\n\", num_data['Q6.05b'].value_counts())\n",
    "cum = 0\n",
    "minus = 100\n",
    "total = sum(num_data['Q6.03'].value_counts())-1 #-1 is for the -99\n",
    "y_axis_for_histogram = [366, # More than once a day\n",
    "                        365, # every day\n",
    "                        286.79, # 5-6 times a week (5.5)\n",
    "                        182.5, # 3-4 times a week (3.5)\n",
    "                        104.29, # 2 times a week \n",
    "                        52.15, # 1 time a week\n",
    "                        30, # 2-3 times a month (2.5*12)\n",
    "                        12, # 1 times a month\n",
    "                        6, # once every 2 months\n",
    "                        3, # once ever 3-6 months\n",
    "                        1, # once a year\n",
    "                        0.5, # less than once a year\n",
    "                        0 # not currently using cannabis while programming\n",
    "                        ]\n",
    "counts_for_histogram = []\n",
    "reversed_y = list(reversed(y_axis_for_histogram))\n",
    "for x in range(12, -1, -1):\n",
    "    current_num = num_data['Q6.03'].value_counts()[x]\n",
    "    counts_for_histogram.append(current_num)\n",
    "    current_percent = current_num/total*100\n",
    "    cum += current_percent\n",
    "    print('{:7} {:7} {:>7.1f} {:>7.1f} {:>7.1f} {:7}'.format(x, current_num, current_percent, cum, minus, reversed_y[x]))#-1 is for the -99\n",
    "    minus -= current_num/total*100\n",
    "\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "And let's investigate the frequency of how much they currently use cannabis\n",
      "percent who used cannabis in last year while programming 73.21428571428571\n",
      "have used regularily\n",
      " -1.0     151\n",
      " 1.0     128\n",
      "-99.0      2\n",
      "Name: Q6.05b, dtype: int64\n",
      "     12      20     7.1     7.1   100.0     366\n",
      "     11      10     3.6    10.7    92.9     365\n",
      "     10       6     2.1    12.9    89.3  286.79\n",
      "      9      13     4.6    17.5    87.1   182.5\n",
      "      8      27     9.6    27.1    82.5  104.29\n",
      "      7      15     5.4    32.5    72.9   52.15\n",
      "      6      19     6.8    39.3    67.5      30\n",
      "      5      37    13.2    52.5    60.7      12\n",
      "      4       8     2.9    55.4    47.5       6\n",
      "      3      23     8.2    63.6    44.6       3\n",
      "      2      10     3.6    67.1    36.4       1\n",
      "      1      33    11.8    78.9    32.9     0.5\n",
      "      0      59    21.1   100.0    21.1       0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "# And let's try and generate some sort of histogram here\n",
    "y_axis_for_histogram, counts_for_histogram\n",
    "# Now let's try and spread it out over the year\n",
    "histogramer = []\n",
    "for how_common, count in zip(y_axis_for_histogram, counts_for_histogram):\n",
    "    histogramer += [how_common for x in range(0, count)]\n",
    "\n",
    "plt.figure(figsize=(9,5)) #change your figure size as per your desire here\n",
    "plt.ylabel('Cumulative Percentage of Responses (n = 280)', fontdict={'size': 12})\n",
    "plt.xlabel('Number of Times Used Per Year', fontdict={'size': 12})\n",
    "plt.title('Frequency of Cannabis Use While Programming\\n(By participants who have done so at least once)', fontdict={'size': 14})\n",
    "\n",
    "plt.hlines(0.9, 0, 365, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.vlines(12, 0, 0.5, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.text(15, 0.2, '50%: 12 or\\nmore times\\nper year', fontdict={'size': 12})\n",
    "\n",
    "\n",
    "plt.hlines(0.8, 0, 103, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.vlines(104.29, 0, 0.83, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.text(107.7, 0.2, '20%: 100 or\\nmore times\\nper year', fontdict={'size': 12})\n",
    "\n",
    "plt.hlines(0.5, 0, 12, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.vlines(365, 0, 0.9, colors='r', linestyles='dashed', linewidth=1)\n",
    "plt.text(285, 0.2, '10%: daily use\\n(365 or more\\ntimes per year)', fontdict={'size': 12})\n",
    "\n",
    "\n",
    "plt.xticks(np.arange(0, 380, 25))\n",
    "plt.xticks(np.arange(0, 380, 25), [str(x) for x in range(0, 355, 25)] + ['Over\\n365 times\\na year'])\n",
    "#bins = sorted(X) + [np.inf]\n",
    "\n",
    "plt.hist(histogramer, bins=[x/2 for x in range(0, 780)] + [np.inf], range = (0, 375), cumulative=True, density=True, histtype='step', linewidth=3)\n",
    "\n",
    "\n",
    "plt.show()\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/usr/local/lib/python3.9/site-packages/matplotlib/axes/_axes.py:6752: RuntimeWarning: invalid value encountered in multiply\n",
      "  tops = (tops * np.diff(bins))[:, slc].cumsum(axis=1)[:, slc]\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 648x360 with 1 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAF4CAYAAAB3gKKVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAB0P0lEQVR4nO3dd3hUVfrA8e9Lb6G3gCEgohQVhaACKuhasIB1XZFqAXTtZVcRf4KK3VXX1V3EhiKIrhUUFESxrYUiSlMEpHeQEmqA9/fHuRluhpnkJpnJJJn38zzzJLfMPe+9586dM+eee46oKsYYY4wxxVmZRAdgjDHGGJMXK7AYY4wxptizAosxxhhjij0rsBhjjDGm2LMCizHGGGOKPSuwGGOMMabYswKLMUVARC4Qkd9EZJ+IjEp0PLEgIk1FREUkozDrlDYislRE7sjPOkHeYwrPOxcvTXQcpmCswGJyEJFR3oc6/HVcomMr4V4C3gHSgZujrSQizUXkJRFZISJ7RGSZiLwtIp2KLNLYWgGkArML8mYR6S8imVGWxe3LR0QGicgOEangm1dBRHaKyNywdY/wYvlTPpLoAPw7VvF6cUzzfV73iMhCEblbRMrGMp0SLhWYkOggTMFYgcVE8inug+1/zQ1fyX8xN9GJSE2gDvCJqq5S1a1R1ssAZgFtgOuA1kB3YCbwr6KJNrZUdb+qrlXVfYmOJZ8+B6oAJ/jmnQhsBVqISD3f/NOAPcA3QTeuqhtUdWcsAg3zCu7zehTwDDAciFhzE8/Pb3G9Nnjn4p5Ex2EKxgosJpI93gfb/9rn/YL7j4g8ISIb8C7QItJaRD4Ske0isl5E3hCRhtkbE5Gy3nv+8F5Pe9uZ5ltnmog86w/Cq+350DctIvJ3EVksIrtEZI6I9PYtz779cImITPF+Dc8XkTPDtttSRMaLyFYRyRSRb0XkGBE5VUSy/LF76z8oIj9HO1giUktEXvX2bZeIfCoibbxlXYE/vFU/8+LrGmEbAowClgCdVfVDVV2sqj+r6sPAn3zrPiIiv3ppLRWRx0Skkm/5MBGZKyKXe8dqu4i8LyJ1w4+tiNwsIqu82F8RkSq+dbqJyFfess0i8omItIpwCI4Uka9FZLeI/CIiZ0XIkwxvuryIPCMiq71agBUi8ki0YxtUXtv1akceFZGV3nkxXUTOjrY9VV0IrMYVRrKdBkwFZgBdw+Z/q6q7ffMqicjzIrLNS/NvYfHmegtIRGqIyEjv87RdRL6QYLfVdnqf16Wq+qwX74XeNrPz/E4RWQms9OYf452zu7x8HiUiNXyxlBORp3yf36eifH4jXRtuE5GfxdVWrRKRF8UV4LPf19/7DJ7jnTs7vc9mDRG5VNxt1K0iMlpEKkdI7x9ezBu8c7miiDwnIltEZLmI9Ak7rqFaOQl+vTjP+7ztFpEvvc+VikjTAPlhYsgKLCa/egMCnAL0FZFU4EtcDcwJwBlANeADEck+v24HBgCDgI5AWaBXAdIeDlwNXI+rfXgYeF5Ezgtb70Hcr8u2wHRgnIhUAxCRRsDXgAJnAu2A54CyqvolsBjom70hbx/64m7pRDMK9+v7Atwx2Al87F1g/4erMQG4BPfr938RtnGct97jqro/fKGqbvFN7gCuAloBfwUuB4aEvaUp8BfgIuAs4HjccfE7BTgal2fZ6/pvV1UFnvb2qSuudmGCHPrr+THc8T4OmILL+8YR9hHgJi+dy4EWXrq/Rlk3P/La7itAF+AK3D6/6u1L21y2+TmHFlimeS///K7eun63AnNw59ejwGMi0jHIjoiIAB8BjYHzcXn3Ja7AmxpkGz67gPK+6S7AsUA34E8iUhX4BMjE5fNFQCfgZd977gD6A9cAJ+G+N66IkFaOa4M37wBwC+7cvsJLI7y2sCLuGtELVzDPwN0+7Yf7zFyIOw5/DXtfL2A77rP3CO5cfR9Y6G3jVeDFAMcst+tFE+BdXH609dZ7LI/tmXhRVXvZK/TCffnuw13Asl+TvGXTgJ/D1r8fmBo2rxauQHCCN70aGOJbXgZ3UZnmmzcNeDZCLB96/1fFXXxPCVvnaWCi939TL91BvuWNvXkne9MPAsuAClH2/w5ggW/6HFx1f50o67fwtn+qb14N3Jf7Nd50XW+drrkc98u8dY4vQJ5dCyzyTQ8DdgM1fPOGhK0zCte+pKxv3gvAp7mkUxXY7zuW2cc7Ut4OD1snw5t+BverXwLuW38gM8oyBS7Na7tAc9wXZ5Ow+e8D/84l7au9c64iUMk7pkfgCoALvHVa+s8vb95S4I2wbf0G3BO2zh2RpoHTcZ+7ymHbmA38PZd4p+F9hrx86Oadu4/68nwDUNH3ngHeuZrim9fV26cjvOk1wF2+5YIrDIZ/fn+OFptvveyYyvjyV4GjfOs84Z1ndcPO1w/D0vs2LKYNwHjfvPLA3uxzJMI505S8rxcP47seePPu9tZpmt/Pqr0K9yqHMYf6Ehjom97l+39m2LrtgVMlcsPI5iLyK65W4dvsmap6QES+B9LyEVNr3JfGxyLiH7GzPO5i7+e/fbPa+1vf+3s88LWq7o2SzqvAgyLSSVX/h6vJeF9VN0VZvxXuy9C/f1tFZI4Xc1ASeEVXpX0L7suzGq7GKrxh5TLN2VZmNQePQbb5mrM2ZzXu12p2Os2BB7x59XBfgmWAJmHbiZS30fZ9FK4WZqGITAYm4grEB6KsH1Ru222HO77zXeVFSEXgs1y2+RnunOvovX+Dqi4SkTW4c7shrqZlJ/B92HvDbyFGOv7RtMe1n9kQFm8lXOErNwNFpD+QXQs2GrjPt3yu5mzD0QpX0Njum/c/3Dnd2ru90xD4IXuhqqqI/MChn9/wawMicjow2EunBu48reBtM/uzuUdV/bVh64C1qroxbF74ORU6xl5M63G1WtnzskTkD/I+7rldL1rial38wvPaFBErsJhIdqrqoijLdoRNl8FVl0a6H7+O4LcdD3Dol7a/Kjt7O92B5WHrZUWb9i5k/vfnSlU3iMh44CqvsNXDS7Mg8jMU+kLvbyvgx2grichJwDjcl9CtwBZcjE+ErRp+TJRDj0Fe63yIa+cwCFiFq3mbz8Evw3xT1Vnevf+zcdX/rwI/iciZUQot24DKIlJeVUPx+tpBbM1ru94+Ke7JnPB93kUUqvq7iCzD1TgI8IU3f4eIzPTmd8UVgKOeg9mbI/hnoQzus3NKhGXb8njvm7hzYw+wWg+9vRj++c1Nfs7fQ7YtIum4a8MLwL3AJlzh8Q1ynkPhDbKVgp+/BTnuBb5emKJlBRZTWLNwtzOWRbhoA+D9Ij0J79esd4/+BFxVc7YNuJoYv7YcrD2Zj7sIp6tqbr+K8/Ij0FtEKuRSy/IC8DauAexa3FNT0SzAXdw64mqmEJHqwDG4dhNBzcbt499E5M3wLxoRqamuHUtnYJWqPuBblp6PdAIRkTq4X5d/VdXPvXntiHzNiJS3b0fbtvdr/m3gbXF90nyHqy1aGGH1X3HH93h8v/JxX3zZy/Pa7o+4AkfD7H3Jh+x2LAK85ps/DXfrpivwZD63mZdZQAPggKouyed7t+byYyOSBbjCeYqvlqUT7pgv8GoL1+IKe/487oD7bOQmA1cwuTX7fBaR8/MRW3HwC65tmt8JkVY08WelSFNYz+Gqet8UkRNF5HAROUPcEw4p3jr/BP7utfo/CtfuJLxw8hlwjoj0EJGjRORJfFXO3sX0CeAJEblKXN8Xx4nItSIykOD+jbuN8paIdPC201Ny9jMzBfdrcCgwKrfbFar6G/ABrvHvKSJyDPA67pfw2KBBqaoCV+Kq/L8WkfPF9clyjIj8nYOFpoVAYxHp5R3r64CeQdPJhz+AjcAA7xh1AUZw6K9hgOvC8jYd+E+kjYp7aqSniLQSkSNwDTG34T2xEk5V5wGTcY0nzxCRZuKe7vk38JaqLs9ru+qe+BkDjPLiPFxEMkTkDhG5OI/j8DmuQHYirpCS7QtcA9/6HNrgtrA+xT1l84G4p2eaiUhHEblPRCLVuhTGGNwtrde8c+1U4HngXV/BJ/vze5GXx//AfX7zqoH5Dfcdc4u3Dz1xtzJLkhG4239PeNeli3E1jpD/GihTSFZgMYWiqqtxv/oPAB8D83CFmD3eC9wF7hXgRdz93zK4C6Xfy77XN7jW/++FrfN/uAald3jpTME9RfB7PuJdBZyK++X3Oe7X9434voi9wsMruFtSQWpJrsT9+h/v/a0CdFPVqLcbosT2A679wi+4C+UC3G2ZE4AbvHUmAI/jCgY/4550ujc/6QSM5QDuSZtjcU+APYc7/pH6sLgLuA34Cdeo8iJVjVgAweXr33DHaRbuyaJzNPc+Sf6Cy6sRuHz/F66QeHU+tnslLi8fwx3fD3HnwbJc0sVLtwKwPqzm4mugMq5QdEjbjcLwzr9zcYX4F3C1SG/h+lZZnctbC5LWTtxttOq4Y/cBrk3SVb7VnsC1hXkFV2sF7rPpf4w70rZ/xj11dhuu9vAaovQJU1yp6jLcNaYH7vy+lYNtgnLdfxN74j4bxhQtcX2uHK2qXRMdSyQi8h/cUxJn5rmyMUlGRH7Etd25MdGxFDURuRn3dGRNtS/QImVtWIzxEddhVmtcPxKXJTgcYxLOayN1Nu42WHnco9DHen9LPRG5Hvek0Abc7cH/w90qtsJKEbMCizE5fYC7BfOSqn6U6GCMKQYO4Arwj+Nu587H3W6bkdCois4RuL5X6uDaWo3A1bCYIma3hIwxxhhT7FmjW2OMMcYUe1ZgSXLiBu5b5/VqWuqIb7CzAOv2l8g99pY6ItLVOzZ18147X9stUcfQe7R5aaLjKO7y8zlKRiLyg4hckug4SjsrsJi7cWPxLIYcI5hmv/aIyELJZWTZ4kDCRnb2SQUmBNzMm8DhsYsqGAkb0diYolCczzvxRhxPdBz58ADwiBwc8NXEgR3cJCYiVXB9I0Qaibgb7sv+SNwAYA+LyF+KMLxARKSMiISPoxOiqmvDxk6JSlV3qer62EVnjEkSE4EU3GCpJk6swJLczsX11vhNhGWbvC/7Zar6Cq7TpHYAInKqiGSJG/wtREQeFJHwQd/8y5d6v5xeF5FMEVkbXnPj9Vj6s4jsEJFVIvKiHBw3JnTLQUTO9X6B7cXVjPQDzvPVDHX11s9RlS0ijURkjIhsEpGdIjJbRE7zb9u37jARmSsi14jIchHZJSLv+2+jiOstd7KIbBSRbSLytYh0DNsnFZGBIvJfb7+WiEhv3yrZHd9N99ad5r3vGBGZ6m03U0R+yo41wrHtJiLbRaScN32Et60RvnWGi0j4MANtReR771jMENf9vn+7F4vIHK+mbYWIDBHJOSJflHj+5B27HSLyuYg08y1rLiIfePm/Q0Rmia/LdhF5SNxYPeHb/J+IPOObvlJE5ovIbq8W8Na8fuGKyN+9dDNF5DVcr8f+5WVE5P+8fd3j7fsFvuXZtRKXiMgU77jNFzdmkX87rUXkIy9P1ovIG+Gflwix3Ssiy7x013rxZS+rKCJPi7t9u1tEvhORk/PYXjcR+UpE/hCRzSLyiYi08q0S8bwLQkQai8g4b9t/ePvawrc81zz21rlY3Gd9lxffFyLSQNzgjUOBNnLw89w/l1gGicgiEdnr/R0Qtjyvz1+u1wVveXcRmekd+9/FXetC4yF5Qw9MJD69TptsiR4u2l6Je+G63J4SNq8prhCT4U0LrifbHcDFvvV+wTfUPa7wuwK4OZf0luJ6Bh2Cq7kZhCtw+Ld7C26MlqZAF1xvrqN9y/vjeqX91ovrSNwvmzdxPd829F4VvPX9w8lXxXUX/g1uYLnmwMXAab5tZ/rSGgZk4rpkP95Lbx45h7A/HeiDG7SwJfAsrlv7Or51FPc4ZG/cI5IPe/vdxFvewVvnbC/22t78Obhu/lt677sI6Bjl2FbDDeJ2kjd9Da7fiF9863wN3OP939VL8wfcWDktgU9wvetmPz3YHtiP69nzSKCXdzxuzCWP+3txfIp7PPxYXG/Cn/jWaQtcixtv6QjvfNgLtPSWt/Zia+l7z+HevBO86QG4saguBZrhBqhcC9yQS2yXeekM8vZnCO58XOpb51Zv3hXeOvd7x+C4sM/HL16aLXADLW4CqnnrpOKGNXjUOy+Oxd2W/B4oEyW2S7x0z8ONhp3h3xfcZ3WNt7wVrgfcTCA1l/29xHu18GJ4C1jEwc9GxPMuyrb8n6MquCEiRnnbbYnrxXoZUCVgHjf0pm/3junRuHO2Aa4H4Se8Y5z9ea4cJa6LcOfbDV5+3ehNd8/H5y+v68LZXt5kD51xGq734SfCYrkWWJHIa3ppfyU8AHslMPPhfeDVsHnZF+Sd3gVxrzf9VNh6d+AGR8uePgfXbXudXNJbyqEFpBdxPWZGe083b7tlvOn+Xjztw9YbBXwY4f3+C+0AXBfudaOk1Z9DCyz7sy9s3ryTvW22iLINwX2x9A6L4WHfdDnv+PYOO+YZYdvaBvTLR35+Bwz2/n8d9yt1F+4LtIp3HE/2lnf10jzb9/7O3rzDvOkxwGdhaQzDjc8TLYbs/DnKN6+Xl7bkEfs9vulZwAO+6XuAX33Ty4E+Ydu4BZifSxr/A14Im/cpOQssq4B7w9aZBrwelleDfMsbe/Oyj+39wNSwbdTCV+CKENttuC/B8hGWVcV9Dvv65pUFFgPD83F+VPXO55PD9iUjwHv9n6OrcF/wEhbPJuCyIHmMq61V3GCmkdYdBswNENc3wMth80bhu6aQ9+cvr+vCl8D/hc27EHd99B+DHrg+a8oFzRN75e9lt4SSW2Wij4dxBW48lra4X6Y9RWS4b/mrwOEi0smbvgp4X1U35ZHmtxGmW2dPiMjpXlX7ShHZDryLG8vFX52+Dze6cX4dD/ysqhvz8Z5V6g2w5/ked1Fq5cVbX0Se925JbMVd+OrjfiX7hW6Vqeo+XO1H/TzSfhI36N9n3q2YlnmsPw1XEAFXOzXJi7crbgTefeQc8ThHXBwcpyY7rlYcervwa9zgi9VziWOPqv7qm16Ny8NaACJSVUQe826l/CHuNlwGOY/Z67hzMFsvvPGnRKQebmDM571bO5neNh7B/QKOphWRzz+87VYHGkXZ59Zh83I7bu2BU8NiW+Etixbff4FKwO8i8pKI/FlEKvreU94fl7pbEDk+O+G82zJjRWSxiGwD1uFqQsPPzfxqj6vV2u7bv624/G3upZ1XHv+EKyzOFZF3ROQ6L1/zK9o5GjW/Inz+8routAeGhOXnWFwB0H9d2oX7wVKpAPthArCebpPbRrwvkQhW6sHB3haIe+z5AREZrqq7VXWDiIzHDU3/K+7XRffCBCOuC/CPcNXd9+J+sbUD3sB94WXb412wi4NXcdXYt+JqkPYAU8kZL7hqaj8ljzZkqjpMRMbgaq/OBoaKyLWq+nKUt0wDbvDaKVTHDco3DVeFvR74VlX35hKXen+D/JDRXJaFj+gcvt0ncDVnd+B+qe8EXiPnMXsDeExce6A9uNsOr4dt51pcrUlRCN/f0HFTVRXXrCc7rjK48zjSk3XrIm5cdYW4kZD/BJyBGzB0qIicmM+4/D7E3QoZhKs52ofrpTb83MyvMrgfDJdHWLbZ+5trHqvqfhE5C9fV/Vm4gSwfFpEuqvpTIeODXPLLtzzoD/YyuNui/42wbIPv/9rAblUtMY/1lzRWYEluP+Kq8IPYjztfKnCwVuYF4G1gCa79QHiDzkhOijC9wPs/w9v+rdkFkvCGernYi6uWzs2PQB8RqZuPWpbGIpKmqtm/kE/AXcCyYz4ZuEm9bvxFpAHuFkx+ZBciDolfVX/DXfCfETcg4zW4Ea0j+RqoCPwdVyW+32tI+QLui/LjfMa1AHebyO9kXGF2ez63Fb6N11T1HQARqYT7Zb4wewVVXSMin3HwdtK3qrrEW7ZORFYDzVX1tUO2Ht0C3PnmP36h81FVt3nb7YwrdPrjnZ+PdGbhaiWXqWr4F2VUqrobV9D5SEQewX2mOuNqEPZ6/2d3P1AW6Ij7pX8IEamDK+T9VVU/9+a1I+c1P+p5l4dZuMalG1V1S5R1guSx4mqJvhWR+3Htw/6Cq30J8nmGg+eo/0nH/OZXXteFWbi2N4siLPM72lvXxIndEkpunwCtvItbuDoi0lBEDhORc3DDxH+uqtt860zB1YIMxQ0GdiBAmieJyGARaeG15u8LPOUt+w13Tt4iIs1EpCeuXUIQS4GjReQoEakrIuUjrDMWV9PwgYicIiKHi0gPifLkjWcX8KqIHOf92h8BfOQVJMBdgHuLeyqkAzCOg18EQa330jlb3FMSNUSksog8J66Dt6beL+1cL8TeL7uZuMaFn3uzvwMOw30xT8tnXP8Auoh7WupIEemFayT5WD63E24hcJGItBORY3A1J5Gq0V/HfYFdzsHalWxDgb+LezLoKBE5WkT6isjgXNL9J9BPRAZ4599gILwG43HgDhHp6e3z/biGmE/kY/+eA2oAb4rIid55doaIjBSRlEhvEPeE2jXingxrhmvgmQX8pqo7gP8Aj4p7Oq6VN90A+HeUGP7A1aAOEPfEWBfcueuv/TrkvAu4f2NwBeAPRKSL91k9VUT+IQefFMo1j0XkJBG5R9xTdk1wNbRpHDy/lwLp3vvr+m6PhXscV9i43svTG3GF3Pyco3ldF+4HrhCR+73zrKWIXCoi4WmcQv5/FJj8SHQjGnsl9oX7hXO9b7oprro0+7UPd/99JFAvwvvvxbXpaBograW4xnRv4BqsrQPuDFvnJlz19S7cr9zLvDiaesv742sY63tfPWAyrg2JAl29+aHGgt70Ybgnirbgqql/9K2bY9terHOBgd4x2IUbHLGeb522uHYiu3C/fvt47xnmWydHDL5jcYdv+hpcQ9L9uIJFBdyFdCmuhmG1lwfV8zjGjxDWkNLb3g68p0O8eV299er65jWN8N6LcU8r7fWOwRBybzx7SP6EpwWk42rjduBuWdyBu30xKux91bx19hKhMTfuV/4sXI3fH7gapsvzOD6DcV9O2e0QhpGz0W0Z3Gi8K7x05wAX5naMopxnLXC1j39458avwL/8eRD2/gtxn8Ut3j5PB873La8IPI37zOzBFURPzmNfT/fOxd3e37O9/e4f7bzLZVvh+9cAeMU7lntwj0i/HDSPcW1PJvn2ZxE5nzqs6Dt+6o85QmzXeu/P8v4OyC32KJ+/qNcFb/lZwFfesm3ADHI+xdXYO18Oy+s6aK+Cv2zwwyQnIt1wvzxbawHahXi3KY5Q1TMDrLsUeFZV8/NrNWFEZBjuQnd0omMxxhRfIvI4UENVByY6ltIscBsWEakG1AS2qDUqKjVU9WMReQ73C2NZ0Pd51cetcbd0LotTeMYYUxKsJ3+3DU0B5FpgEZGjcS3Mz8NV8Qmg3i/lScDzqjon3kGa+FLVZ/Je6xAf4BqgvqReg1NjjElGqvp4omNIBlFvCYnIONwv6HG4e+ALcO0DUnD3H7vg7iHPV9VIj7cZY4wxxsREbgWW81U10ui3BVrPGGOMMaagrNGtMcYYY4q9PBvdes/89wHa4G4Hbcd18DNaVRfk9t54q1u3rjZt2jSRIRhjjDEmRmbOnLlRVSMO05BXo9ueuA6KxuMGgNqK6/K7LfA/cd2EvxnjeANr2rQpM2bMSFTyxhhjjIkhEYn6tGpeNSwPAeepavjgUohIZ1yPhwkrsBhjjDEmOeTVNX89oo+N8CNQN7bhGGOMMcYcKq8CyxTgZXEj9YZ40y94y40xxhhj4iqvAstV3t/5IpIpIqtFJBPX6FZ8y40xxhhj4ibXNiyq+gfQU0SqAEfiBiPLBBaq6s4iiM8YY4wxJthYQl7hZHb2tIjUxo1aaYwxxhgTd7neEhKRVBF5R0QWiMg/RKSmiHwHbBSRFSKSUURxGmOMMSaJ5dWGZQTuFtDtQENgKvAhUAvXP8uTQRIRkZdFZL2IzI2yXETkGRFZJCI/i0i7wHtgjDHGmFIvr1tCnYFGqrpXRKYBW4CTVDVLRB4H7giYzijgWeC1KMvPAVp4rxNxhaETA27bGGOMMaVcXgWWfbiebTcCNbz1q+B6vK0MZAVJRFW/FJGmuaxyAfCauoGNvvNuPaWq6pog2zfGGGOS0cgvF/Pp/PVFmmbvjun0aNuoSNOEvAss7wNTROQT4GRcr7Yvi8gooC+x64elMbDCN73Sm2cFFmOMMSaK3zfu5Ielm4s0zTNbNyjS9LLl1YblJuANXC3LzcAgYBeuy/7t3vIiJSIDRWSGiMzYsGFDUSdvjDHGmATIqx+WvcBjYbN7xyGOVUCab/owb16kmEYCIwEyMjI0DrEYY4wxJc41JzcrktqPJnWqxD2NSAL1w1IExgM3iMg4XGPbrdZ+xRhjjAmuWb2qnHh4nUSHETd59cPSUEQmichWEfmfiHQKW74tSCIi8gbwLXCUiKwUkatF5FoRudZbZSKwBFiEG6Por/neE2OMMcaUWnnVsPwTWA10BboAE0TkRlUd6y2XIImoas88litwfZBtGWOMMSb55FVg6Qqkq+pu4EcR+QyYKCJVVfUFwNqQGGOMMSbu8iqwlPOvo6o/i0hX3KPOKXGMyxhjjDEmJK/HmmcCZ/tnqOoiXM3LX4Gq8QnLGGOMMeagvGpY/g83blAOqrpMRLoAV8clKmOMMcYYn7z6Yfk+l2WrgPtjHpExxhhjTJi8bgkZY4wxxiScFViMMcYYU+xZgcUYY4wxxZ4VWIwxxhhT7AUusIjI333/3xWfcIwxxhhjDpWfGhZ/IeXuWAdijDHGGBNNfgosEuV/Y4wxxhSxn1Zs4ZtFGxMdRpHJT4FFo/xvjDHGmCJ2/4fzWb55Z6LDKDIFrWExxhhjjCky9pSQMcYYU8JVLFeGhtUrJTqMuMprLCE/uw1kjDHGFENjrjmRjKa1Ex1GXFmjW2OMMcYUe4ELLKpay/d/SnzCMcYYY4w5lLVhMcYYY0yxZwUWY4wxxhR7+Wl0a4wxxkSVtf8Aao9nFJkDSXawrcASzbBhcN99B6dnzHB/MzIOzhs61K3XqBGsWePmtWsHM2fCwIHwwgsH1121ys3v0ePgvOefd+uJrw3z+efDhAnQvTt8+OHB+aowciQMGnRw3vjx0L49NG58cN6AAW699u1h1iw3LzUVVq+2fbJ9sn2yfYrrPv35zjHMLle6n1QxiSNagktoGRkZOiP7A2WMMSahLnzuG2av2JLoMJLS29d2LBWPNYvITFXNiLQsUA2LiDQDHgSOA6r5l6lqk8IGaIwxpnQpW0YoYx1gFI29e3NUwpVWQW8JjQUWA7cDyTNwgTHGmAL577UdadekVt4rmsITgcdL7t2SoIIWWNoAnVX1QDyDMcYYY4yJJGiB5UvgeGBmHGMxxpRSE+es4feNOxIdhomzddt2JzqE5DRgQKIjKBJBCyxLgY9F5D1grX+Bqt4b66CMMaXL+z+uYvL8dYkOw5jSaeTIREdQJIJ2HFcV+BAoD6T5XofFKS5jjDHGBNG+faIjKBKBalhU9cp4B2KMSQ7d2jTk8HpVEx2GibMG1SslOoTkkd2fTikXtcAiIg1UNc863KDrGWMMwIXHN6bb0Q0THYYxpoTJ7ZbQZyLybxHpKCI51hORMiJykoj8G5ga3xCNMcYYE1VqaqIjKBK5FViOB+YDLwDbRWSOiPxPROYA24ARwBygXfzDNMYYY0xEq1cnOoIiEfWWkKruBZ4FnhWRNOAYoCbwB/Czqq4qkgiNMcYYE92wYe5VygV6SkhVV6jqRFUdq6qTrLBijDHGFBP+AStLsaCPNRtjjDHGJIwVWIwxxhhT7FmBxRhjjCnJZsxIdARFImjX/DmISGXggKruiXE8xhSJj+euYdkmG3i8qNg4QsaYwgpUYBGRJ4C3VPUHETkPeBtQEfmLqk6Ia4TGxMHbM1fy6YL1iQ7DGGMKLyMDVBMdRdwFvSXUC5jr/X8v0BvoATwUj6CMMcYYY/yC3hKqoqo7RaQOcLiqvgMgIunxC82YonFW6wY0rWtj2xSVZnasjTEFELTAslBEegFHAFMARKQusCtegRlTVP6ckcaZrRskOgxjjCmYoUMTHUGRCHpL6K/A9cDpwP95884GJgdNSES6icivIrJIRO6KsLyJiHwuIj+KyM8icm7QbRtjjDFJKwl6uYWANSyqOh3oFDZvDDAmyPtFpCzwHHAmsBKYLiLjVXW+b7V7cA17/yMirYGJQNMg2zfGGGOSVqNGSTGeUOB+WETkTBF5SUQmeNMZInJ6wLefACxS1SXeGEXjgAvC1lGguvd/DaD0H31jjDGmsNasSXQERSJQgUVEbgT+A/wGnOrN3gUMD5hOY2CFb3qlN89vGNBbRFbialduDLhtY4wxxpRyQWtYbgHOUNVHgAPevF+Ao2IYS09glKoeBpwLjBaRQ+ITkYEiMkNEZmzYsCGGyYcZNgxEDr5mznQv/7zs+4aNGh2c1769mzdwYM51V6+GCRNyzhs5MnunDr66d3fzunfPOR/c+v55Eya47frnDRzo1m3f/uC8Ro1sn8L36csvC3uGGGNM8dCuXaIjKBKiATqbEZH1QKqq7heRzapaW0QqAb+ramqA93cEhqnq2d70YABVfdi3zjygm6qu8KaXACepatTevTIyMnRGknRJbGLrmlenhzqOe6Fvhj0lZIwxxYCIzFTVjEjLgtawfAmEP9lzE/B5wPdPB1qISDMRqQBcDowPW2c58Ccv4FZAJSCOVSjGGGNMKZBdC13KBS2w3AhcJCJLgRQR+RW4DLgtyJtVdR9wA/AJsAD3NNA8EblfRHp4q90ODBCRn4A3gP4apPrHGGOMSWYvvJDoCIpE0Mea14hIB6ADkI5rQPuDqh7I/Z05tjER15jWP+9e3//zgc5Bt2eMMcaY5BH4sWZ1flDV/wKVgVPiF5YxxhhjzEFBH2v+QkQ6e//fietHZayI3B3P4IwxxhiTh1WrEh1BkQhaw3I08J33/wDgNOAk4Np4BGWMMcaYgGbOTHQERSLo4IdlABWR5rhHoecDiEituEVmjDHGmLz16AFJ8IxK0ALL18CzQCrwHoBXeNkYp7iMMcYYY0KC3hLqD2wBfsZ1oQ/QEvhnzCMyxhhjjAkT9LHmTcDdYfM+iktExhhjjAnu+ecTHUGRCFRg8Xqn7Q8cB1TzL1PVvjGPyhhjjDHBJElPt0HbsLwKtAUmAOviF44xxhhj8kXEGt36dAOaqeqWOMZijDHGGBNR0Ea3y4GK8QzEGGOMMSaaoDUsrwEfiMg/CbslpKqfxTwqU6QmzVnDr+u2JzqMIrVkw45Eh2CMMbFx/vmJjqBIBC2w3OD9fShsvgKHxy4ckwiT5q5l/E+rEx2GMcaYgpgwIdERFImgjzU3i3cgxhhjjCmA7t2TotAStIYFESkHdAIaAyuBb1V1X7wCM4lxdpsGHNWweqLDKDr330ez27okOgpjjCm4Dz9MdARFImg/LC1xjzRXBlYAacBuEemuqgviGJ8pYucek8oFxzVOdBhF56yxUH9MoqMwxhiTh6BPCf0bGAmkqWpHVT0MGOHNN8YYY4yJq6AFluOAJ1Vz9EzztDffmJIrCTpbMsaUcklyHQtaYFkNhN/oP8Wbb0zJNXJkoiMwxpjCSZLrWNACy93AeBEZJyKPisg4YDxhAyIaU+IMGpToCIwxpnCS5DoWqMCiquOBdsBcIMX7215VP4hjbMYYY4wxQD4ea1bVhSLyIFAX2BjWnsUYY4wxJm4C1bCISE0RGQ3sAtYCu0RktIjUjmt0xsTb+PGJjsAYYwonSa5jQduwvILrg+V43C2h43GDIb4cp7iMKRrt2yc6AmOMKZwkuY4FvSV0OtBQVXd50wtEpD/2lJAp6Ro3TppHAo0xpVSSXMeCFlh+AZoC/l5tmwC/xjogc9CXCzfw/uxVcU9n1vI/4p6GMcYYUxhBCyxTgcleO5bsrvl7A6NF5KrslVTVbhHF0KL1mbw7K/4FFmOMMaa4C1pg6Qgs8v529OYtxg2G2MmbVqxNiylpBgxIdATGGFM4SXIdC1RgUdXT4h2Iyd3JR9TlwuPjPyjh8Wm14p5GsZIkPUQaY0qxJLmOBR2tuR6wS1UzRaQs0BfYD7yuqgfiGaBxjqhfjUvbH5boMEqf9u1h5sxER2GMMQWXJNexoI81fwi08P5/CLgDuA34RzyCMqbIzJqV6AiMMaZwkuQ6FrQNy5HAbO//Xrh2K5nAPODW2IdljDHGGHNQ0ALLfqCCiBwJbFXV5SJSBqgWv9CMKQKpqYmOwBhjCidJrmNBCyyTgLeAOsA4b15rwJ65NSXbauv70BhTwiXJdSxoG5ZrgI+Al4CHvXl1gWFxiMmYojNsWKIjMMaYwkmS61igAouq7lHVkcCrQD1v3jRVHZf7O40p5u67L9ERGGNM4STJdSw/ozWPBXbjOpBDRHqIyPB4BmeMMcYYA8FvCY0AtgLpwF5v3rfAX+IRlDHGGGOMX9BGt38CGqlqlogogKpuEJH68QvNmCIwY0aiIzDGmMJJkutY0BqWrbhGtiEi0gRYE/OIjDHGGGPCBC2wvAi8IyKnAWVEpCOuAe7zcYvMmKKQkZHoCIwxpnCS5DoW9JbQo8Au4DmgPG5U5udV9ek4xWWMMcYYExJ0tGYF/um9QkTkPFX9KB6BlTS7s/azZ19sx4HclbU/ptszxhhjSqo8Cywi0gI4Flikqj9583oAQ4E0IFDDWxHphivwlAVeVNVHIqxzGa4zOgV+UtUrgu1G4j396W+M+GJxosMw+TV0aKIjMMaYwkmS61iuBRYR6Q+8AGwG6ojIbbgnho7BjdT8cpBERKQs7nbSmcBKYLqIjFfV+b51WgCDgc6q+oc9gWSKRJL0EGmMKcWS5DqWVw3LnUAPVZ3k1aq8AzwDXKqqWflI5wRcDc0SABEZB1wAzPetMwB4TlX/AFDV9fnYfrFSoVwZKpYL2p45mErly8Z0e8bTqFHSjMNhjCmlkuQ6lleBpZGqTvL+n4AbtfmufBZWABoDK3zTK4ETw9Y5EkBEvsHdNhqmqh+Hb0hEBgIDAZo0aZLPMIrGLWe04K9dj0h0GCaINfZkvjGmhEuS61he1QCS/Y/X8HZnAQorQZUDWgBdgZ7ACyJSM3wlVR2pqhmqmlGvXr04hWKMMcaY4iSvGpaqIrLcN10jbBpVDVLNsQrXQDfbYd48v5XA916B6HcRWYgrwEwPsH1jCqZdu0RHYIwxhZMk17G8Ciynxyid6UALEWmGK6hcDoQ/AfQ+rmblFRGpi7tFtCRG6RsT2cyZiY7AGGMKJ0muY7kWWFT1i1gkoqr7ROQG4BNc+5SXVXWeiNwPzFDV8d6ys0RkPq6tzN9UdVMs0jcmqoEDYeTIREdhjDEFlyTXsdg+ypILVZ2oqkeqanNVfdCbd69XWEGd21S1taoeo6rjiio2k8ReeCHRERhjTOEkyXWsyAosxhhjjDEFZQUWY4wxxhR7UQssIrLa93+gHm2NKXFWhT+sZowxJUySXMdyq2EpLyJ1vP8vLYpgjClySdK63hhTiiXJdSy3p4SeB1aIyEagSnj/K9kC9sNiTPHUoweoJjoKY4wpuCS5jkUtsKjqPSLyPJAOTAb6FFlUxhhjjDE+efXDsgJXy9I9Vn2yGGOMMcbkV6CnhFR1qohcKSKficiv3t8r4x2cMXH3/POJjsAYYwonSa5jeXXND4CIDAH6Av8AluFuE/1dRBpldwJnTIk0cGCiIzDGmMJJkutYoAILcA3QVVWXZc8QkU+ALwErsJiSSyQpGqsZY0qxJLmOBe04riqwIWzeJqBybMMxxhhjjDlU0ALLx8AYETlKRCqLSEvgVdyAhcYYY4wxcRW0wHIDsB34GcgEZgM7gBvjE5YxReT88xMdgTHGFE6SXMcCtWFR1W1AXxHpD9QFNqrqgXgGZkyRmDAh0REYY0zhJMl1LF+DH6rqAVVdb4UVU2p0757oCIwxpnCS5DpmozWb5Pbhh4mOwBhjCidJrmNWYDHGGGNMsWcFFmOMMcYUe4ELLCJypoi8JCITvOkMETk9fqEZUwSSoLMlY0wplyTXsUAFFhG5EfgP8Btwqjd7FzA8TnEZUzRGjkx0BMYYUzhJch0LWsNyC3CGqj4CZD8h9AtwVDyCKhaGDXPdHWe/Zs50L/+8YcPcuo0awaOPJDJaU1CDBiU6AmOMKZwkuY4FHUsoBVjh/Z9d91Qe2BvziIqLYcMOFkj8IlW9rV4Nk36BLxbHOypjjDEmKQWtYfkSuCts3k3A57ENxxhjjDHmUEFrWG4EJojIACBFRH7FddWfHP0Bm9Jr/PhER2CMMYWTJNexoF3zrxGRDsAJQBPc7aEfrMdbU+K1b5/oCIwxpnCS5DoWtIYFVVXge++VlJ6Z+hvvzloZcdnmHaW3OU+p1rhx0jwSaIwppZLkOhaowCIiKzjY2NZvD7ASeBf4j6rui2Fsxc7mHXtZumlnosMwxhhjkk7QGpZngN7e3xW420LXA/8FNgO3A2nA3+MQozHGGGOSXNACS3/gTFVdnT1DRCYBk1W1jYh8DnxKEhVYbjjtCC5pf9ihC+65h1onnFn0AZmCGTAg0REYY0zhJMl1LGiBJRXIDJu3A2jk/b8QqBmjmEqE2lUr0Kxu1UMXjHiq6IMxBZckPUQaY0qxJLmOBe2HZQLwgYicISItReQM4B1vPkBHYGkc4it5kqS1dqlh+WWMKemS5DoWtMAyCPd00PPAj8BIYDpwrbd8CXBezKMriWbNSnQEJj8sv4wxJV2SXMeC9sOyG9fTbXhvt9nL18YyqOJi1979vPrt0tD0nFVbExeMMcYYk8QC98MiIhVwgx3WBSR7vqp+Foe4ioWde/fxyKRf8vem1NT4BGPiw/LLGFPSJcl1LGg/LCfjHmGuCFQHtnFwQMTD4xZdSbR6dd7rmOLD8ssYU9IlyXUsaBuWp4DHVLU2sN37+wDw77hFVsxULFeGQaceHnodc1iNyCtGGuHZFF+WX8aYki5JrmOiAbrzFZGtQC1VPSAif6hqLe8W0e+q2jjuUUaRkZGhM2bMiNv2N2Xuof3wTwH3GPOs/wvQv4pIUnSRXGpYfhljSrpSdB0TkZmqmhFpWdAalq24W0EAa0SkNVALqBaD+IwxxhhjchW0wPIucK73/8vA58BM4O14BGWMMcYY4xf0seZbfP8/ISLf4RrdfhynuEquON6iMnFg+WWMKemS5DoWqIZFRJ7xT6vq16o6CdcY1xhjjDEmroLeEuofZX6fGMVRemREbCtkiivLL2NMSZck17FcbwmJyFXZ6/n+z3Y4sDEuURljjDHG+OTVhiW7BqUCOWtTFFgH9AuakIh0A/4JlAVeVNVHoqx3Ca4xbwdVTY4bc8YYY4zJVa4FFlU9DUBEhqvqPQVNRETKAs8BZwIrgekiMl5V54etlwLcjBtosWQaOjTREZj8sPwyxpR0SXIdC9SGJbuwIiL1ReRw/ytgOicAi1R1iaruBcYBF0RY7wHgUWB3wO0WP0nS42CpYflljCnpkuQ6FvQpobNFZBWwFljke/0WMJ3GuHGHsq305vnTaAekqepHecQyUERmiMiMDRs2BEy+CDVqlOgITH5YfhljSrokuY4FfUro37jaj6qqWsb3KhuLIESkDPAkcHte66rqSFXNUNWMevXqxSL52FqzJtERmPyw/DLGlHRJch0LWmCpBTyvqrsKmM4qIM03fZg3L1sKcDQwTUSWAicB40UkOZ7VMsYYY0yughZYXgKuLEQ604EWItLMGzTxcmB89kJV3aqqdVW1qao2Bb4DepTIp4TatUt0BCY/LL+MMSVdklzHAnXNj6vxuElE7sK1YwlR1VPzerOq7hORG4BPcI81v6yq80TkfmCGqo7PfQslyMyZiY7A5IfllzGmpEuS61jQAsuL3qvAVHUiMDFs3r1R1u1amLQSauBAGDky0VGYoCy/jDElXZJcx0RVEx1DgWVkZOiMOA76tClzD+2HfwpA7aoVmPV/Z+b9JhEowcc06Vh+GWNKulJ0HRORmaoasf1qoBoWERHgGqAnUFdVjxWRU4GGqvpW7EItHjZm7mHNlt1s3ZWV6FCMMcYYQ/BbQvfjeql9GhjhzVuJG6251BVYPvxpNcMmzM97RWOMMcYUifyM1ny+qo7DjSME8DtuAETjt2pV3uuY4sPyyxhT0iXJdSxogaUskOn9n11gqeabV2rVrlqBoxtXp2XDlGBvSJLW2qWG5ZcxpqRLkutY0FtCE4EnReRWCLVpeQCYEK/Aiovux6Zy3wVHB39Djx6lpvFTUrD8MsaUdElyHQtaw3IbkApsBWrgalbSgTvjFJcxxhgTM9OmTeOwww4LtO6YMWM466yzQtMiwqJFi+IVmgko6GjN21T1IqAJrhO55qp6kapuj2t0pUDXrl2pVKkS1apVo1q1ahx11FE5lo8dO5b09HSqVq3KhRdeyObNm0PLbrnlFmrVqkXHjh1ZuXJljvfcdNNN+Yrj888/57TTTqNGjRo0bdo0x7L169fTs2dPGjVqRI0aNejcuTPff/99/ne2FNizZw9XX3016enppKSkcNxxxzFp0qQc60ydOpWWLVtSpUoVTjvtNJYtWxZa9vjjj1O3bl3atGnDnDlzQvO/+eYbLrzwwnzFMnfuXM4++2zq1q2Lq9TMafPmzVx00UVUrVqV9PR0xo4dm2N5bueWMfHy7LPPkpGRQcWKFenfv/8hy4vq81MYvXr1YvLkyUWWngkm6GjNZ4nIkaq6XlWnq+paETlKRAJ0TJJknn/+kFnPPvssmZmZZGZm8uuvv4bmz5s3j0GDBjF69GjWrVtHlSpV+Otf/wrADz/8wMyZM1m7di0nn3wyjzzyCABbt27l8ccfZ/jw4fkKq2rVqlx11VU8/vjjhyzLzMykQ4cOzJw5k82bN9OvXz/OO+88MjML30Rp3759hd5GXIXl1759+0hLS+OLL75g69atDB8+nMsuu4ylS5cCsHHjRi6++GIeeOABNm/eTEZGBn/5y18AWLNmDS+99BJLlizhuuuuY/DgwaFt3n777Tz99NP5Cq18+fJcdtllvPTSSxGXX3/99VSoUIF169YxZswYrrvuOubNmwfkfm4Vhqpy4MCBQm/HlF6NGjXinnvu4aqrrjpkWVF+fpJKhO+dUklV83wBvwGpYfMaAQuDvD9er/bt22s8vPL1Ek2/80NNv/NDvff9OYXaVpcuXfSFF16IuGzw4MHas2fP0PSiRYu0fPnyum3bNh03bpzeddddqqo6adIkPeecc1RV9frrr9cxY8YUOJ4pU6Zoenp6nuulpKTojBkzIi7bvXu33nzzzZqamqqpqal688036+7du1VV9fPPP9fGjRvrI488og0aNNDevXsXONbi4phjjtG3335bVVWff/557dixY2hZZmamVqpUSRcsWKDfffedXn755aqqumDBAm3VqpWqqj7++OP64IMPFjj93377Td1H9aDMzEwtX768/vrrr6F5vXv31jvvvFNVcz+3Ivnmm280IyNDq1evrhkZGfrNN9+ElnXp0kXvvvtu7dSpk1aqVEl/++23Au+LSR5DhgzRfv365ZhXlJ+fnTt3ar9+/bRmzZraqlUrfeyxx7Rx48ah5Q8//LAefvjhWq1aNW3VqpW+++67oWWvvPKKdu7cOTQN6G+//aY//PCD1q9fX/ft2xda9s477+ixxx4bMYbw679/uwcOHNBbbrlF69WrpykpKXr00UfrnDnu+2b37t16++23a1pamtavX18HDRqkO3fuzPcxKIlww/VE/M4P2oalvqqGj1+9BmgYm2JTKRKh6n7w4MHUrVuXzp07M23atND8efPm0bZt29B08+bNqVChAgsXLqRNmzZ89dVX7Nq1i6lTp9KmTRtmzJjBr7/+yhVXXHFIGl9//TU1a9aMyS7Mnj2bvXv3csQRR0Rc/uCDD/Ldd98xe/ZsfvrpJ3744YccNT5r165l8+bNLFu2jJHFvbvoCPnlt27dulB+wKF5VrVqVZo3b868efM44ogjmDNnDlu2bOHTTz+lTZs2rFixgnHjxnHHHXccsu3ly5dTs2ZNli9fnu+wFy5cSLly5TjyyCND89q2bZujhiXauRVu8+bNnHfeedx0001s2rSJ2267jfPOO49NmzaF1hk9ejQjR45k+/btpKen5zteY6BoPz/33XcfixcvZvHixXzyySe8+uqrOZY3b96cr776iq1btzJ06FB69+7NmjXhX3M5dejQgTp16uS4XTR69Gj69u2bn8MAwOTJk/nyyy9ZuHAhW7du5a233qJOnToA3HXXXSxcuJDZs2ezaNEiVq1axf333x99Y3lcx0qLoAWWJSJyeti8rri+WEqV/Qc0pp3GPfrooyxZsoRVq1YxcOBAunfvzuLFiwF3K6ZGjRo51q9Rowbbt2/n6KOP5pJLLuGkk05i+fLl/P3vf+emm27imWee4ZlnnuHUU0+lV69ebNmyBYCTTz459H9hbNu2jT59+jB06NBDYss2ZswY7r33XurXr0+9evUYOnQoo0ePDi0vU6YM9913HxUrVqRy5cqFjilRsrKy6NWrF/369aNly5ZA7nlWp04dhgwZwumnn85HH33EE088wc0338yjjz7Ke++9R5cuXbjgggtC7ZGaNGnCli1baNKkSb5jy8zMpHr16hHjyCvOcB999BEtWrSgT58+lCtXjp49e9KyZUsmTDj4EGD//v1p06YN5cqVo3z58vmO1xgo2s/PW2+9xZAhQ6hduzZpaWmHtPv785//TKNGjShTpgx/+ctfaNGiBT/88EOe+9CvXz9ef/11wBX2P/nkk4g/IvNSvnx5tm/fzi+//IKq0qpVK1JTU1FVRo4cyVNPPUXt2rVJSUnh7rvvZty4cflOo7QJWmAZBrwrIv8Qkb+KyD+Ad4CIgxeag0488URSUlKoWLEi/fr1o3Pnzkyc6MaArFatGtu2bcux/rZt20hJcX2+3Hrrrfz000+8+eabvPXWW5x66qkcOHCAkSNHMnXqVFq1ahVq2xILu3btonv37px00kmh+8eRrF69Osev7PT0dFavXh2arlevHpUqVYpZXIlw4MAB+vTpQ4UKFXj22WdD8/PKs549ezJr1iwmTZrE3LlzqVixIscffzx33HEHEyZM4M9//nPEX4v5lVcceS33C89PcHm6ytcZVVpaWqFjNqYoPz+rV6/Ocd6Gn+OvvfYaxx13HDVr1qRmzZrMnTuXjRs35rnd3r17M2HCBHbs2MFbb73FKaecQmpqaqCY/E4//XRuuOEGrr/+eurXr8/AgQPZtm0bGzZsYOfOnbRv3z4UW7du3diwYUO+0yhtgj4l9AFwFlAVOM/7e7Y33/idf36ui0Ukuw0Qbdq04aeffgotW7JkCXv27MlRzQ/utsTIkSO59957mTt3Lsceeyzly5enQ4cO/PzzzzEJe8+ePVx44YUcdthhPJ9HA65GjRrlaNm/fPlyGjVqFJqO9ERLsRUhv1SVq6++mnXr1vHOO+/kqFEIz7MdO3awePHi0C2jbLt27eLuu+/mH//4B7/99htpaWlUr149Znl25JFHsm/fPn777bfQvJ9++ikUR9BzCw7NT3B52rhx49B0icpTU2wV5ecnNTWVFStWhKb9t46WLVvGgAEDePbZZ9m0aRNbtmzh6KOPDl2bc9O4cWM6duzIu+++y+jRo+nTp0/UdatWrcrOnTtD02vXrs2x/KabbmLmzJnMnz+fhQsXhp6Sqly5MvPmzWPLli1s2bKFrVu35v4QRB7fO6VFngUWESkrIouBn1T1WlU9z/s7vQjiS7i7z2uVvzf4qtG3bNnCJ598wu7du9m3bx9jxozhyy+/pFu3boB7dG7ChAl89dVX7Nixg3vvvZeLL774kF/Bt912G8OGDaNKlSo0a9aM6dOnk5mZybRp0zj88GCjIxw4cIDdu3eTlZWFqrJ792727t0LuFsfl156KZUrV+bVV1+lTJncT4uePXsyfPhwNmzYwMaNG7n//vvp3bt3fo5S8THh0L4Pr7vuOhYsWMCECRMOuaV10UUXMXfuXN555x12797N/fffz7HHHhu6ZZRt+PDh9O/fn0aNGtGkSRN+/fVX1q1bx+effx44z8Lzaffu3ezZswdwF8KLL76Ye++9lx07dvDNN9/wwQcfhC6eQc8tgHPPPZeFCxcyduxY9u3bx5tvvsn8+fM5P0kugia29u3bx+7du9m/fz/79+8PXf+gaD8/l112GQ8//DB//PEHK1eu5F//+ldo2Y4dOxAR6tWrB8Arr7zC3LlzA+9j3759eeyxx5gzZw4XX3xx1PWOO+443n33XXbu3MmiRYtyPPE3ffp0vv/+e7KysqhatSqVKlWiTJkylClThgEDBnDrrbeyfv16AFatWsUnn3wSPaAI17FSKVprXP8LWAjUCLJuUb7i8ZTQvv0HQk8INbvrw/xv4PzzQ/+uX79eMzIytFq1alqjRg098cQTdfLkyTlWHzNmjKalpWmVKlW0R48eumnTphzLp06dqueee26OeTfffLPWrFlTTzzxRF2xYoWqqn755ZdatWrVqGF9/vnnihtWIfTq0qWLqqpOmzZNAa1cubJWrVo19Pryyy8jbmvXrl164403asOGDbVhw4Z644036q5du0Lp+FviF3u+/FJVXbp0qQJasWLFHMfi9ddfD60zZcoUPeqoo7RSpUrapUsX/f3333NsY8GCBZqRkZHjSYLHHntM69Spo61atdKff/5ZVVWXLVumVatW1WXLlkUM7ffffz8kz/xPeG3atEkvuOACrVKliqalpR3y9Fhe55bfV199pe3atdPq1atru3bt9Kuvvgoty+1JN2PCDR069JDzdujQoaHlRfX52bFjh/bp00dr1KgR8Smhu+++W2vVqqV16tTRW2+9VU899dTQeR7tKSH/tlNSUrRv3765HosNGzbomWeeqdWqVdNOnTrp0KFDQ9v99NNP9ZhjjtGqVatqnTp19IorrtDt27erqrvGDh48WJs1a6YpKSnasmVL/ec//xk9obDrWElGLk8JiQaoAhORvwIXAA/hRmkOvUlVl8Sm6JR/GRkZOmPGjJhuc/8Bpfndro1JGYElD5+Xvw2IJEUXyaWG5ZcxpgCaN2/O888/zxlnnJHoUErVdUxEZqpqRqRlQccSym51GN5RnOIGRjTGGGOSwjvvvIOIcPrp4Q/PmngKVGBR1aBPExljjDGlVteuXZk/fz6jR4/Os72fia2gNSwAiEga0FhVv4tTPCVfKamWSxqWX8aYfPB3/llsJMl1LOhYQk1E5BvgF+BTb96lIvJiPIMrkYp7z64mJ8svY0xJlyTXsaD1Wc8DHwEpQJY3bwqHtmkxgwYlOoLAli9fTrVq1di/f3+iQ0mcEpRfYHlmSobBgwfbYIVFqYRdxwoqaIHlBOARVT2A94SQqm4FIvfdboqlpk2b8umnn4ammzRpQmZmJmXLWrvp4sryzJQ0GzZs4LXXXmOQ9yU6f/58MjIyqFWrFrVq1eKMM85g/vycw5/MmjWLU089lWrVqtGgQQP++c9/hpY1bdqUypUrU61aNapVq8ZZZ51VpPtjio+gBZZ1QI6R8ESkNZD/UdtMTGR3xGRKDsszkwxGjRrFueeeG+p0sVGjRrz99tts3ryZjRs30qNHDy6//PLQ+hs3bqRbt24MGjSITZs2sWjRokMKJRMmTCAzM5PMzMwcAw8WRlF/Hu3zX3hBCyxPAB+KyJVAORHpCbwJPBq3yEqq8eNzTDZt2pTHH3+cY489lqpVq4a6fD/nnHNISUnhjDPO4I8//vC9fTxt2rShZs2adO3alQULFuTY1qOPPhra1r59+/juu+/o1KkTNWvWpG3btlEbhPXp04fly5fTvXt3qlWrxmOPPcbSpUsRkdAHqWvXrtxzzz106tSJatWq0b17dzZt2kSvXr1C3WIvXbo0tM1ffvmFM888k9q1a3PUUUfx1ltvhZZNnDiR1q1bk5KSQuPGjXniiSdicHDjICy/wPKs2OeZKdYmTZpEly5dQtM1a9akadOmoWFJypYty6JFi0LLn3zySc4++2x69epFxYoVSUlJoVWrfPYw7tm6dSt9+/alXr16pKenM3z4cA4cOAC4glTnzp259dZbqVOnDsOGDTvk/cOGDePPf/4zvXv3JiUlhWOOOYaFCxfy8MMPU79+fdLS0nIUmFavXk2PHj2oXbs2RxxxBC+88EKObV166aX07t2b6tWrM2rUKLZu3crVV19NamoqjRs35p577onN7d0I17FSKVqPcuEvXMdxE4F5wCTgwqDvjderWPZ0u2pVjsn09HQ98cQTde3atbpy5UqtV6+eHn/88Tpr1izdtWuXnnbaaTps2DBVVf3111+1SpUqOnnyZN27d68++uij2rx5c92zZ09oW23bttXly5frzp07deXKlVq7dm396KOPdP/+/Tp58mStXbu2rl+/PmJo6enpOmXKlNB0dk+qWVlZqup6NG3evLkuWrRIt2zZoq1atdIWLVrolClTNCsrS/v06aP9+/dXVdXMzEw97LDD9OWXX9asrCydNWuW1qlTR+fNm6eqqg0bNgz1lLt582adOXNm/o9lUQjLL1XLM9VinmemWKtbt67+8MMPh8yvUaOGli1bVkVEH3jggdD80047TW+66Sbt2LGj1qtXT88///wcvdemp6dr/fr1tW7dunrmmWfq7Nmzo6bdp08f7dGjh27btk1///13bdGihb744ouq6nqvLVu2rD7zzDOalZWlO3fuPOT9Q4cO1YoVK+rHH38c+vw0bdpUhw8frnv37tWRI0dq06ZNQ+ufcsopet111+muXbv0xx9/1Lp16+rUqVND2ypXrpy+9957un//ft25c6deeOGFOnDgQM3MzNR169Zphw4ddMSIEfk/yOEiXMdKKnLp6TZIQeUs4DbgtLzWLepXsSywQI7J9PT0HN26X3zxxXrttdeGpp955hm94IILVFX1/vvv1z//+c+hZfv379dGjRrp559/HtrWSy+9FFr+yCOPaO/evXOkd9ZZZ+moUaMihhbky2/48OGh5bfddpt269YtND1+/Hht27atqqqOGzdOTz755BzbHzhwYOiLPC0tTUeMGKFbt26NGEuxEZZfqpZnxT7PTLFWrlw5XbBgQcRlmZmZ+txzz+mHHx68trZo0UJr1KihP/zwQ2jYj06dOoWWf/3117pz507dsWOHPvTQQ9qgQQP9448/Dtn2vn37tHz58qECuKrqiBEjQkOQvPLKK5qWlpZr7EOHDtUzzjgjND1+/HitWrVqaJiAbdu2KaB//PGHLl++XMuUKaPbtm0LrX/XXXdpv379Qts65ZRTQsvWrl2rFSpUyFFQGjt2rHbt2jXXmAKJcB0rqXIrsOR6S0hE7gTeAy4HJojI9fGo5SntGjRoEPq/cuXKh0xnj8K5evXqHEOglylThrS0NFatWhWa5x8ufdmyZfz3v/8NDUFes2ZNvv76a9asWRP3WJctW8b333+fI+0xY8aERiN95513mDhxIunp6XTp0oVvv/22wDElguVZycszUzzUqlWL7du3R1xWtWpVrr32Wvr27Rsa2K9y5cpcdNFFdOjQgUqVKjF06FD+97//sXXrVgA6d+5M5cqVqVKlCoMHD6ZmzZp89dVXh2x748aNZGVl5fg8pqenR/0sRhP++albt26okXt2u5zMzExWr15N7dq1cwwomlt6y5YtIysri9TU1NDnb9CgQaHjYPKWV8dxg4A/qep3ItIZGAk8F/+wklOjRo2YM2dOaFpVWbFiBY0bNw7NE5HQ/2lpafTp0yfHfdPc+N9bWGlpaXTp0oUpU6ZEXN6hQwc++OADsrKyePbZZ7nssstyDPVeWlieGZPTsccey8KFC+nQoUPE5QcOHGDnzp2sWrWK+vXrc+yxx+Y4z/M657PbwoSrW7cu5cuXZ9myZbRu3Rpw3QBE+ywWVqNGjdi8eTPbt28PFVpySy8tLY2KFSuyceNGypXLV5+txpNXo9u66vVqq6rfAA3jH1IJN2BAgd962WWX8dFHHzF16lSysrL4xz/+QcWKFenUqVPE9Xv37s2ECRP45JNPQsO4T5s2jZUrV0Zcv0GDBixZEpuxKs8//3wWLlzI6NGjycrKIisri+nTp7NgwQL27t3LmDFj2Lp1K+XLl6d69erFtwvrQuQXWJ4ZE+7cc8/liy++CE1PmTKFH3/8kf3797Nt2zZuu+02atWqFWpYe+WVV/Lee+8xe/ZssrKyeOCBBzj55JOpUaMGy5cv55tvvmHv3r3s3r2bxx9/nI0bN9K5c+dD0i1btiyXXXYZQ4YMYfv27Sxbtownn3yS3r17x2U/09LS6NSpE4MHD2b37t38/PPPvPTSS1HTS01N5ayzzuL2229n27ZtHDhwgMWLF+c4VgVWyOtYSZHnFUmcMiJS9uCklMl+FUGMJUshehw86qijeP3117nxxhupW7cuEyZMYMKECVSoUCHi+mlpaXzwwQc89NBD1KtXj7S0NB5//PFQq/hwgwcPZvjw4dSsWbPQT4CkpKQwefJkxo0bR6NGjWjYsCF33nkne/bsAWD06NE0bdqU6tWrM2LECMaMGVOo9OKmkD1EWp4Zk1Pfvn2ZOHEiu3btAmDLli307NmTGjVq0Lx5cxYvXszHH39MpUqVADj99NN56KGHOO+886hfvz6LFi1i7NixAGzfvp3rrruOWrVq0bhxYz7++GMmTZpEnTp1Iqb9r3/9i6pVq3L44Ydz8sknc8UVV3DVVVfFbV/feOMNli5dSqNGjbjooou47777ch29+bXXXmPv3r20bt2aWrVqcemllxbqdnBIkvR0K5Gq1kILRUIdxWXP8k0LrqFPwnqwysjI0BkzZsR0m/sPKM3vnghAGYElD5+Xvw20bw8zZ8Y0JhNHll/GxNzdd99N/fr1ueWWWxIdSnIoRdcxEZmpqhmRluV1I61ZHOIp3WbNSnQEJj8sv4yJuYceeijRISSXJLmO5VpgUdVlRRWIMcYYY0w01gYl1lJTEx2ByQ/LL2NMSZck1zErsMTa6tWJjsDkh+WXMaakS5LrmBVYYi3C+BSmGLP8Miauli9fTrVq1WIzZo7hX//6F3feeWfOmUlyHctXgUVE0kTkpHgFUyrcd1+iIzD5YfllTEw1bdqUTz/9NDTdpEkTMjMzQ73FmsIZMGAAY8aMydlDbpJcxwIVWESkiYh8A/wCfOrNu1REXoxncOagRA5NbsOiF4zlmTGlT6I/15UqVeKcc87htddeS1gciRK0huV54CMgBcjy5k0BzoxHUKVJ06ZNefjhh0MdBV155ZXs3r07tPzDDz/kuOOOo2bNmnTq1Imff/45x3sfffRRjj32WKpWrXrIB+X666/n9ttvzzGvR48ePPXUU4Ab5+aSSy6hXr16NGvWjGeeeSa03g8//EDHjh2pWbMmqamp3HDDDezduze0XER47rnnaNGiBS1atIjpMSnuLM+MKZg+ffqwfPlyunfvTrVq1XjsscdYunQpIhL6LHTt2pV77rmHTp06Ua1aNbp3786mTZvo1asX1atXp0OHDixdujS0zV9++YUzzzyT2rVrc9RRR/HWW2+Flk2cOJHWrVuTkpJC48aNo3auOGrUKDp37swNN9xAjRo1aNmyJVOnTg0t37p1K1dffTWpqak0btyYe+65J3QLK/u9t956K3Xq1GFY2O2XtWvXUqVKFTZt2hSaN2vWLOrVq0dWlvu6fPnll2nVqhW1atXi7LPPZtmygw/g3nzzzaSlpVG9enXat2+fY5ykYcOGcemll9K7d2+qV6/OqFGjQsfwo48+ykfOlBLRRkX0v4BNQBnv/82++VuCvD9er2I5WvOMGTkm09PTtU2bNrp8+XLdtGmTdurUSYcMGaKqqrNmzdJ69erpd999p/v27dNRo0Zpenq67t69O/Tetm3b6vLlyyMOhf79999ramqq7t+/X1VVN2zYoJUrV9a1a9fq/v37tV27dnrffffpnj17dPHixdqsWTP9+OOPvTBn6LfffqtZWVn6+++/a8uWLfWpp54KbRvQM844Qzdt2hQx7VIjLL9ULc+MKYwgI4w3b95cFy1apFu2bNFWrVppixYtdMqUKZqVlaV9+vTR/v37q6ob3fmwww7Tl19+WbOysnTWrFlap06d0IjMDRs21C+//FJVVTdv3qwzZ86MGNMrr7yiZcuW1SeffFL37t2r48aN0+rVq+umTZtUVfXCCy/UgQMHamZmpq5bt047dOigI0aMyPHeZ555RrOysiJ+ts455xz997//HZq+5ZZb9IYbblBV1ffff1+bN2+u8+fP16ysLH3ggQe0Y8eOoXVHjx6tGzdu1KysLH3iiSe0QYMGumvXLlV1Iz6XK1dO33vvPd2/f38o7ZkzZ2qtWrUOBhDhOlZSkctozUELLPOBI9VXYAFaAz8HeX+8XvEosHz+y7qYF1j+85//hKY/+ugjPfzww1VV9dprr9V77rknx/pHHnmkTps2LfTel156KdfkWrZsqZMnT1ZV1X/96196zjnnqKrqd999d8hQ6g899FDoQhDuqaee0gsvvDA0DejUqVNzTbtUiFJgsTwzpmCCFFiGDx8eWn7bbbdpt27dQtPjx4/Xtm3bqqrquHHj9OSTT86x/YEDB+qwYcNUVTUtLU1HjBihW7duzTWmV155RVNTU/XAgQOheR06dNDXXntN165dqxUqVMhREBk7dqx27do19N7wz2W4cePGaadOnVRVdd++fdqgQQP9/vvvVVW1W7du+uKLL4bW3b9/v1auXFmXLl0acVs1a9bU2bNnq6orsJxyyimHrLNw4UItU6bMwRlJUmAJekvoCeBDEbkSKCciPYE3gUeD1uSISDcR+VVEFonIXRGW3yYi80XkZxGZKiLpkbYTb5PmrC3cBjIO7VHYP8R4eno6q71H0JYtW8Y//vGP0FDjNWvWZMWKFaHl4e+NpF+/frz++usAvP766/Tp0ye07dWrV+fY9kMPPcS6desAWLhwIeeffz4NGzakevXq3H333WzcuDFq3KVWhPwCyzNj4qlBgwah/ytXrnzIdGZmJuA+E99//32Oz8SYMWNYu9Zdp9955x0mTpxIeno6Xbp04dtvv42aZuPGjXOMnpz9uV62bBlZWVmkpqaG0hg0aFCORq15fa4uuOAC5s+fz++//86UKVOoUaMGJ5xwQmgfbr755tC2a9eujaqyatUqAJ544glatWpFjRo1qFmzJlu3bs3xuY6U9vbt26lRo8bBGVGuY6VNoDGuVfVlEdkEDAJWAH2B/1PV94O83xs48Tlcm5eVwHQRGa+q832r/QhkqOpOEbkOeAz4S+A9iRH/ALUHog+zlC8rVqwI/b98+XIaNWoEuBNxyJAhDBkyJOp78xoOvXfv3hx99NH89NNPLFiwgAsvvDC07WbNmvHbb79FfN91113H8ccfzxtvvEFKSgpPP/00b7/9dr7SLs0sz4wpmFieg2lpaXTp0oUpU6ZEXN6hQwc++OADsrKyePbZZ7nssstyfHb9Vq1ahaqG4lu+fDk9evQgLS2NihUrsnHjRsqVi/yVmNc+VapUicsuu4zXX3+dX375JfQjJHsfhgwZQq9evQ5531dffcVjjz3G1KlTadOmDWXKlKFWrVrZdzaipr1gwQLatm2ba0ylUdCnhMqq6geqeq6qtlHVc4IWVjwnAItUdYmq7gXGARf4V1DVz1V1pzf5HXBYPrYfQwdPjioVYvMY3nPPPcfKlSvZvHkzDz74IH/5iyuHDRgwgBEjRvD999+jquzYsYOPPvqI7du3B972YYcdRocOHejTpw+XXHIJlStXBuCEE04gJSWFRx99lF27drF//37mzp3L9OnTAVdCr169OtWqVeOXX37hP//5T0z2tbSwPDOmYBo0aMCSJUtisq3zzz+fhQsXMnr0aLKyssjKymL69OksWLCAvXv3MmbMGLZu3Ur58uWpXr06ZcpE/0pbv349zzzzDFlZWfz3v/9lwYIFnHvuuaSmpnLWWWdx++23s23bNg4cOMDixYv54osv8hVr3759GTVqFOPHj89RYLn22mt5+OGHmTdvHuAa+P73v/8F3Ge6XLly1KtXj3379nH//fezbdu2PNP64osvOOecc/IVX2kQ9JbQWhH5t4h0LmA6jXE1M9lWevOiuRqYVMC0YmbIea3y/6ahQw+ZdcUVV3DWWWdx+OGH07x5c+655x4AMjIyeOGFF7jhhhuoVasWRxxxRKgVeH7069ePOXPm5PiQlC1blg8//JDZs2fTrFkz6tatyzXXXMPWrVsBVw05duxYUlJSGDBgQOgLOelEyC+wPDOmoAYPHszw4cOpWbNm1Kd2gkpJSWHy5MmMGzeORo0a0bBhQ+6880727NkDwOjRo2natCnVq1dnxIgRjBkzJuq2TjzxRH777Tfq1q3LkCFDePvtt6lTpw4Ar732Gnv37g09GXjppZeyZs2afMXauXNnypQpQ7t27UhPP9ii4aKLLuLOO+/k8ssvp3r16hx99NFMmuS+3s4++2y6devGkUceSXp6OpUqVcrz9tPu3buZOHEi/fr1OzgzynWs1InWuMX/Ao7H3aJZDvwOPAwcE+S93vsvBV70TfcBno2ybm9cDUvFKMsHAjOAGU2aNIldSx/PXe/8HGp0+/p3kRtF5Ud4A7R4+OKLLzQtLS1HgzJTcJZnxpQur7zyinbu3Dnu6Zx22mn6wgsvxDWNZ555Rv/2t7/FNY1EIpdGt0HbsPyIa2PydxHpAvQEPhORNap6bIBNrAL8xcbDvHk5iMgZwBCgi6ruiRLLSGAkQEZGRoxamcRQo0ZFOq5DVlYW//znP7nmmmus/UJBFHF+geWZMaXR9OnTmTVrFh988EFc07nxxhsPnZmA61giFGQsoV+ABbjalqYB3zMdaCEizUSkAnA5MN6/gogcj+ugroeqro+wjZIhn9WIhbFgwQJq1qzJmjVruOWWW4os3VKlCPMLLM+MKY369evHGWecwdNPP01KSkrRB1DE17FEEdW8KylEpCZwCXAFcBIwGXgDGK+qu3N5q38b5wJPA2WBl1X1QRG5H1f9M15EPgWOAbKP/HJV7ZHbNjMyMnTGjBlBkg9s8LtzeOOH5QA8eNHR9Doxn09Xi0CAY2qKCcsvY0xJV4quYyIyU1UjPqcd6JYQsBr4HzAWuERVt+Q3CFWdCEwMm3ev7/8z8rvNYqldu0RHYPLD8ssYU9IlyXUsaIGluaomR51TYc2cmegITH5YfhljSrokuY5FbcMiIqf6JluJyOmRXkUQY8kycGCiIzD5YflljCnpkuQ6lluj23/7/n8pyuvF+IVWQr3wQqIjMPlh+WWMKemS5DoW9ZaQqh7t+79Z0YRjjDHGGHOooF3zR3ywXETejW04xhhjjDGHCtoPy2lR5neNURylx6pD+sMzxZnllzGmpEuS61iuTwl5/aQAVPD9n+1wYFlcoirJZs50vQ6aksHyyxhT0iXJdSyvx5qzu9MvQ86u9RU3mOGwOMRUsvXoUWo68EkKll/GmJIuSa5juRZYVPVKABH5n6omRzNkY4wxxhQ7QQc/fAFARFKAuoD4li2JT2jGGGOMMU6gAouItMJ1y98WdztIvL/gxgYy2Z5/PtERmPyw/DLGlHRJch0L+pTQf4DPgdrANqAWbmTlfnGKq+RKkh4HSw3LL2NMSZck17GgYwm1Bc5U1SwREVXdKiJ/A+YCr8cvvBKoFI2amRQsv4wxJV2SXMeC1rDsBsp7/28UkSbee+vEJSpjjDHGGJ+gBZavgMu8/98GJgFfAJ/FIyhjjDHGGL+gTwld5pu8G5gHVANei0dQJdr55yc6ApMfll/GmJIuSa5jQduwhKjqAWB0HGIpHSZMSHQEJj8sv4wxJV2SXMeiFlhEZDQHH12OSlX7xjSikq5796Q5eUoFyy9jTEmXJNex3GpYFhVZFKXJhx8mOgKTH5ZfxpiSLkmuY1ELLKp6X1EGYowxxhgTTdCebk+PtkxV7UkhY4wxxsRV0Ea3L4VN1wMqACuBw2MaUUmXBJ33lCqWX8aYki5JrmOB+mFR1Wb+F1ADeBB4Nq7RlUQjRyY6ApMfll/GmJIuSa5jQTuOy0FV9+MKLH+PbTilwKBBiY7A5IfllzGmpEuS61iBCiyeM4EDsQrEGGOMMSaaoI1uV5CzT5YqQCXgr/EIyhhjjDHGL2ij295h0zuAhaq6LcbxlHzjxyc6ApMfll/GmJIuSa5jQccS+iLegZQa7dsnOgKTH5ZfxpiSLkmuY0FvCdUAbgKOxw16GKKqZ8UhrpKrceOkecSsVLD8MsaUdElyHQt6S+i/QFngPWBX/MIxxhhjjDlU0ALLSUBdVd0bz2CMMcYYYyIJ+ljz10DLeAZSagwYkOgITH5YfhljSrokuY4FrWHpD0wUke+Bdf4Fqnp/rIMq0ZKkx8FSw/LLGFPSJcl1LGgNy4NAGtAAaOF7HRGnuEquJGmtXWpYfhljSrokuY4FrWG5HDhSVdfEM5hSYdasREdg8sPyyxhT0iXJdSxoDcsSICuegRhjjDHGRBO0hmU0MF5E/sWhbVg+i3lUJVlqaqIjMPlh+WWMKemS5DoWtMByvff3obD5Chweu3BKgdWrEx2ByQ/LL2NMSZck17FAt4RUtVmUlxVWwg0blugITH5YfhljSrokuY4FbcNigrrvvkRHYPLD8ssYU9IlyXUs6FhCK3C3fw6hqk1iGpExxhhjTJigbVh6h02nAjcD42IbjjHGGGPMoQIVWFT1i/B5IjIN+Bj4Z4xjKtlmzEh0BCY/LL+MMSVdklzHCtOGZQ/QLOjKItJNRH4VkUUicleE5RVF5E1v+fci0rQQsRljjDGmFAnahiV8vKAqwLnApIDvLws8B5wJrASmi8h4VZ3vW+1q4A9VPUJELgceBf4SZPvFSkYGaMTmPqY4svwyxpR0SXIdC1rDkhb2qgQ8CfQL+P4TgEWqukRV9+LavlwQts4FwKve/28DfxIRCbh9Y4wxxpRiQduwXFnIdBoDK3zTK4ETo62jqvtEZCtQB9hYyLTzpUPTWmQ/EHVEvWpFmbQxxhhjosi1wCIinYEeqnpnhGWPAO+r6nfxCi5KTAOBgd5kpoj8Gqek6j5S0MJSwSuG6lLEBbQEplt80oxvRZ7laelLM1HpJkuaiUq3ZKcZ/DqWqDwNKj3agrxqWO4G/h1l2TRgCNA9QACrcLeSsh3mzYu0zkoRKQfUADaFb0hVRwIjA6RZKCIyQ1Uz4p1OotNMVLqWZulLN1nSTFS6yZJmotK1NIu/vNqwHId7dDmST4H2AdOZDrQQkWYiUgG4HBgfts54DraJuRT4TDUJWhEZY4wxJk951bBUByoAuyIsKw+kBEnEa5NyA/AJUBZ4WVXneU8fzVDV8cBLwGgRWQRsxhVqjDHGGGPyLLD8ApwFfBBh2Vne8kBUdSIwMWzevb7/dwN/Drq9IhD3207FJM1EpWtplr50kyXNRKWbLGkmKl1Ls5iT3O66iMgVuMeX/4prYHtARMoAF+L6VblNVd8oikCNMcYYk7xyrWFR1bEi0hDXP0pFEdmIa2G8BxhqhRVjjDHGFIU8O45T1SdxfaR0B+7w/jb25pc6eQ0hEMN00kTkcxGZLyLzRORmb/4wEVklIrO917kxTnepiMzxtj3Dm1dbRKaIyG/e31oxTO8o377MFpFtInJLPPZTRF4WkfUiMtc3L+K+ifOMl88/i0i7GKb5uIj84m33PRGp6c1vKiK7fPs8IoZpRj2eIjLY289fReTsgqSZS7pv+tJcKiKzY7yv0T4nccvXXNKMW74W5HpQ2HzNJc1452klEflBRH7y0r3Pm99M3LAsi7wYKnjzCz1sSy5pjvGO31zv/C7vze8qIlt9+3pv7inkK81RIvK7b9vHefMLde6KyGEi8oH3mVgsIv/MPoalhqray3vhGgQvBg7HNTb+CWgdp7RSgXbe/ynAQqA1MAy4I477uBSoGzbvMeAu7/+7gEfjeHzX4p6zj/l+AqcC7YC5ee0bB4eWEOAk4PsYpnkWUM77/1Ffmk3968V4PyMeT++c+gmoiBv7azFQNlbphi3/B3BvjPc12uckbvmaS5pxy9f8Xg9ika/R0iyCPBWgmvd/eeB7L6/eAi735o8ArvP+/yswwvv/cuDNGKZ5rrdMgDd8aXYFPozTfo4CLo2wfoHPXe89PwBXetNlcQ+yPF7IfShX2PyO5aswgx+WRkGGEIgJVV2jqrO8/7cDC3A1WYngHxbhVVwbpXj4E7BYVZfFY+Oq+iXuCTO/aPt2AfCaOt8BNUUkNRZpqupkVd3nTX6H63coZqLsZzQXAONUdY+q/g4swp3nMU1XRAS4DHfRj5lcPidxy9doacYzXwtwPSh0vuaVZhzzVFU105ss770UOB03LAscmqeFGrYlWpqqOtFbprgv/FjmabT9jKYw5+7pwG5VfcVLez9wK3CVV8vTJntFEZkmIhkiUtWrVfpBRH4UkQu85f1FZLyIfAZMzddOx5kVWHKKNIRA3AsRXhXn8bgSOMANXpXgyxLD2zMeBSaLyExxvQYDNFDVNd7/a4EGMU4z2+XkvPjFcz+zRdu3osrrq8g5SGgz7+LwhYicEuO0Ih3PotrPU4B1qvqbb15M9zXsc1Ik+Rrhs5ktbvka8HpQFPsZtzwVkbLerab1wBRcDdEWX4HQvz85hm0BsodtKVSaqvq9b1l5oA85+x3r6N3OmeT/wo9Rmg96efqUiFT05hUmT9sAM/0zVHUbsBz4CFfwxCsAparqDFzHr5+p6gnAacDjIlLVe3s7XC1Ql+B7G39WYEkwEakGvAPc4p1g/wGa4zrtW4Orko2lk1W1HXAOcL2InOpf6P3SiHmHfd691B7Af71Z8d7PQ8Rr36IRkSHAPmCMN2sN0ERVjwduA8aKSPUYJVfkxzNMT3IWRmO6rxE+JyFxPGcjphnPfE3A9SC3Yxu3PFXV/ap6HK5G4wSgZUG2U5g0ReRo3+J/A1+q6lfe9CwgXVXbAv8C3o9hmoNx+9sBqA0cMvRNjE3DdcYKruCSXYt1FnCXV6CahhvUuIm3bIqqBq3FLTJWYMkpyBACMeOV6t8BxqjquwCqus47yQ8AL1DA6vtoVHWV93c98J63/XXZVY/e3/WxTNNzDjBLVdd56cd1P32i7Vtc81pE+gPnA728L1S86vtN3v8zcb8qj4xFerkcz7if0+KG0rgYeNMXT8z2NdLnhDjna5Q045qv+bwexHs/45qnvm1uAT4HOuJugWQ/uerfn9C+Si7DthQgzW7eNocC9XCFsOx1tmXfzlHXh1h5EakbizS9W3GqqnuAV4hNns4nrOd5rzDZBNfT/CYRORb4CwfzVIBLVPU479VEVRd4y3bkaweLiBVYcgoyhEBMePdgXwIWqO+Jq7B7lhcBc8PfW4g0q4pISvb/uBL2XHIOi9CPyB0FFlaOX2vx3M8w0fZtPNBXnJOArb5bDIUiIt2Av+MGDt3pm19PRMp6/x8OtACWxCjNaMdzPHC5uCctmnlp/hCLNH3OAH5R1ZW+eGKyr9E+J8QxX3P5bMYtXwtwPSh0vuZybCG+eVpPDj5hVRk4E9d+5nMO1gSE52mhhm2JkuYvInINcDbQ0ysUZq/f0Ds+iMgJuO/KfBWSckkzu6AtuHY6/jwt6Lk7FagiIn29bZfF1caN8s7VN3Hnbg1V/dl7zyfAjb79PD4/+5cQWgxa/hanF66l9kLcr4chcUznZFw19s/AbO91LjAamOPNH4+73xirNA/HPVnwEzAve/9w94OnAr/hxoiqHeN9rYr7sNfwzYv5fuIKRGuALNz936uj7Rvu18VzXj7PATJimOYi3L3o7HzNfsLhEu+4z8ZVOXePYZpRjyfuXvVi4FfgnFgeX2/+KODasHVjta/RPidxy9dc0oxbvuaSZtzyNVqaRZCnxwI/eunO5eBTSIfjCl2LcLeOK3rzK3nTi7zlh8cwzX3eMcze/+z5N3j7+hOugXWnGKb5mZenc4HXOfgkUaHOXVztzATcZ2Ix7lZW9jFs4O3rUN/6lYHnvbTm4T0VBfQHni1I3sb7lWtPt8YYY4wxxYHdEjLGGGNMsWcFFmOMMcYUe1ZgMcYYY0yxZwUWY4wxppiQKGMQectERB4UkYUiskBEbvLmBxr7SETuDpv+X3z3Jras0a0xxhhTTHiPGVdV1Uyvn5yvgZtV9TsRuRLXK21/VT0gIvVVdb2IdMWNOXV+HtvOVNVq8d6HeLEaFmOMMaaYUCfaGETXAfer12eMug5AAxGRR4DKXg3MGG9epve3q7jhFj4QkSUi8oiI9PJqeuaISHNvvXoi8o6ITPdenb35XXy1Oz9m9/cVa1ZgMcYYY4oRiT4GUXPgLyIyQ9wYRy18b8t17CNVvQvYpa5X214Rkm0LXAu0wo2rdKS6cYZeBG701vkn8JSqdsD1y/OiN/8O4Hp1wxCcAuwq8M7nolzeqxhjjDGmqKgbbfk4r6fc90TkaFWdC1TEjcqcISIXAy/jCgjZYx9lisi5uLGPWkTeelTT1etZV0QWA5O9+XNwt6HA9YDcWg4Oll1d3FhU3wBPejU376qvh+RYshoWY4wxphjSsHGPcD1MZ4/59B6uN100NmMf7fH9f8A3fYCDlRtlgJP04PhDjVU1U1UfAa7B9Z77jYjEZTBLK7AYY4wxxUS0MYi8xe9zsLajC24YmfyMfZTlNeQtqMkcvD2EiBzn/W2uqnNU9VHcmHxxKbDYLSFjjDGm+EgFXvUGMCwDvKWqH3rLHgHGiMitQCauVgPcoJDXicg+XPuRyzXyI8AjgZ9FZFaUdix5uQl4TkR+xpUfvsS1e7lFRE7D1cbMAyYVYNt5sseajTHGGFPs2S0hY4wxxhR7VmAxxhhjTLFnBRZjjDHGFHtWYDHGGGNMICKSsId1rMBijDHGlDAi8r6IzPQGSBwYYfnpIvK+b/pMEXnP+/8sEflWRGaJyH+9zt8QkXu9LvfnishI36PS00TkaRGZAdxcNHt4KHtKyBhjjClhRKS2qm72+mqZDnRR1U2+5QIsAE5R1Q0iMhZ4A/gW1/ncOaq6Q0TuBCqq6v3Z2/TePxr3SPUEEZkGzFfVvxbtXuZkNSzGGGNMyXOTiPwEfAekEdYVv9cPy2igt9cRXUdc/ygnAa1xPdLOBvoB6d7bThOR70VkDnA64B+T6M347Uow1nGcMcYYU4KISFfcuD4dVXWnVwNSKcKqrwATgN3Af1V1n1fzMkVVe4ZtsxLwbyBDVVeIyLCwbe6I9X7kl9WwGGOMMSVLDeAPr7DSEldrcghVXQ2sBu7BFV7A1ch0FpEjAESkqogcycHCyUavTcul8dyBgrAaFmOMMaZk+Ri4VkQWAL/iCiHRjAHqqeoCAK89S3/gDRGp6K1zj6ouFJEXgLnAWly7mGLFGt0aY4wxpZSIPAv8qKovJTqWwrICizHGGFMKichMXNuTM1V1T6LjKSwrsBhjjDGm2LNGt8YYY4wp9qzAYowxxphizwosxhhjjCn2rMBiTDEmIqNEZHiC0hYReUVE/hCRH/L53l4iMjlesRU3IqLZ/VoYY+LDCizG5IOILBWR9SJS1TfvGq+nydLmZOBM4DBVPcG/QETuFpFM77VbRPb7puep6hhVPSsxYYdinCYi14TN6yoiKxMQx27v2GwUkXdFJDUG2x0uIlPD5h0pIttE5JjCbt+Y4sYKLMbkX1kSOGJpQYlI2Xy+JR1YqqqHdMmtqg+pajVVrQZcC3ybPa2qbQ7ZkrnBO1ZHAjWBp/K7gQj59wDQUEQGeMsFeAF4UlXnFC7cUJrWuagpNqzAYkz+PQ7c4Q0oloOINPVuD5TzzQv90heR/iLyjYg8JSJbRGSJiHTy5q/wam/6hW22rohMEZHtIvKFiKT7tt3SW7ZZRH4Vkct8y0aJyH9EZKKI7ABOixBvIxEZ771/ke/L72rgRaCjVzNwX34OkLc/X/umVUT+KiK/efvxgIg0F5H/eTUCb4lIBd/654vIbO8Y/U9EjvUtu1NEVnnb+VVE/pSf2HzbES8f1nsxzBGRo71lFUXkCRFZLiLrRGSEuFFxs9/7NxFZIyKrReSqoGl6I+G+A2SnU+D88/rVuAp4REQaAQOBWsCDeWz3PBH50dvn7DFjspdln79Xi8hy4LP8HFNj4skKLMbk3wxgGnBHAd9/IvAzUAcYC4wDOgBHAL2BZ8WN5ZGtF+7XdF1gNq6rbcTdlpribaM+cDnwbxFp7XvvFcCDQArwNYcaB6wEGuHGDnlIRE73esX015wMLeC++p0NtMeNe/J3YKS3v2m4L/Ce3n4dD7wMDMIdo+eB8V4h4ijgBqCDqqZ421xawHjOAk7F1XrUAC4DNnnLHvHmH4fLl8bAvV583XB5fyZuhNwzgiYoInWBS4AfY5F/qvo9MAo3Ku+DuAJMhTy2uwPoi6vpOQ+4TkQuDNt0F6AV7vgaUyxYgcWYgrkXuFFE6hXgvb+r6iuquh83ZHsacL+q7lHVycBe3Jdkto9U9UvvF/UQXK1HGnA+7pbNK6q6T1V/xP16/7PvvR+o6jeqekBVd/uD8LbRGbhTVXer6mxcrUrfAuxTEI+p6jZVnYcbr2Syqi5R1a24Ye+P99YbCDyvqt+r6n5VfRXYgyvo7AcqAq1FpLyqLlXVxQWMJwtXEGiJ60Rzgaqu8W6tDARuVdXNqrodeAj3xQ+uYPOKqs71bpcNC5DWMyKyBfgJWAPcRiHzz+ce3PkyWlVn5LVdVZ2mqnO8bf4MvIEroPgNU9UdqrorwL4ZUySswGJMAajqXOBD4K4CvH2d7/9d3vbC5/lrWFb40s0ENuNqRNKBE73bJlu8L8ReQMNI742gEZD9hZxtGa42IR7C9zHaPqcDt4ftVxrQSFUXAbfgCgnrRWScdzskkn1A+bB55XEFFVT1M+BZ4DlvWyNFpDpQD6gCzPSl/7E3H9xx8x/XZXnvOjepak1VbayqvVR1A4XPP7z92AX8DszzZuW6XRE5UUQ+F5ENIrIVV5NWN2yzeaZrTFGzAosxBTcUGEDOL/jsBqpVfPP8X0AFkZb9j3erqDZuyPgVwBfeF2H2q5qqXud7b25jb6wGaotIim9eE2BVIeMtrBXAg2H7VUVV3wBQ1bGqejLui1mBR6NsZznQNGxeM3wFDFV9RlXbA61xt4D+BmzEFaDa+NKv4TWaBVdDkubbZpNC7Gdh8q+g2x0LjAfSVLUGMAKQsG3YmC2m2LECizEF5P3afxO4yTdvA+4Lv7eIlPUaZDYvZFLnisjJXqPUB4DvVHUFrobnSBHpIyLlvVcHEWkVMP4VwP+Ah0Wkktew9Wrg9ULGW1gvANd6NQEiIlW9hqIpInKUiJwuIhWB3biCxYEo23kTuFJETvC2cyRwK67dDt6xOlFEyuMKmruBA6p6wIvhKRGp763bWESy23O8BfQXkdYiUgVXcC2IQuVfIbabgqtZ2y0iJ+DayRhT7FmBxZjCuR+oGjZvAO6X+iagDa5QUBhjcV+Km3GNVnsDeLdyzsK1rVgNrMXVNlTMx7Z74mohVgPvAUNV9dNCxlsoXjuMAbjbNX8Ai4D+3uKKuAaxG3H7Wx8YHGU7n+Bu2b0CbAUmAq/iGvsCVMcVTP7A1bpswj0BBnCnl+53IrIN+BQ4ytvuJOBp3BM0iyjgkzQxyr+CbPevwP0ish3XFuutwqRnTFGx0ZqNMcYYU+xZDYsxxhhjij0rsBhjjDGm2LMCizHGGGOKPSuwGGOMMabYswKLMcYYY4o9K7AYY4wxptizAosxxhhjij0rsBhjjDGm2LMCizHGGGOKvf8HW1ICNM56OlsAAAAASUVORK5CYII="
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "print(\"Now let's look at percent usage of weed and percent usage of weed by age:\")\n",
    "\n",
    "#Q5.1: Have you ever used cannabis\n",
    "#Q5.3: Average frequency for using cannabis\n",
    "#Q6.01: Have you ever used cannabis while programming\n",
    "#Q6.03: Cannabis usage pattern by frequency\n",
    "\n",
    "# Ok - first, let's correlate between age and frequency of use while programming\n",
    "# Get those that answered that they have tried cannabis while programming\n",
    "df_have_used_while_programming_and_age = num_data[(num_data['Q1.3'] > 0)&(num_data['Q6.02'] > 1)][['Q1.3', 'Q6.02']]\n",
    "print(spearmanr(df_have_used_while_programming_and_age['Q1.3'], df_have_used_while_programming_and_age['Q6.02']))\n",
    "x = df_have_used_while_programming_and_age['Q1.3']\n",
    "plt.plot(x, df_have_used_while_programming_and_age['Q6.02'], 'ro')\n",
    "plt.ylabel('frequency of cannabis use')\n",
    "plt.xlabel('age')\n",
    "m, b = np.polyfit(df_have_used_while_programming_and_age['Q1.3'], df_have_used_while_programming_and_age['Q6.02'], 1)\n",
    "plt.plot(x, m*x + b)\n",
    "plt.show()\n",
    "\n",
    "# weak positive correlation: https://link.springer.com/article/10.1057/jt.2009.5"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now let's look at percent usage of weed and percent usage of weed by age:\n",
      "SpearmanrResult(correlation=0.20934103511245214, pvalue=0.0025916570695093287)\n"
     ]
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "print(\"Now let's look at percent usage of weed and percent usage of weed by gender:\")\n",
    "\n",
    "women=1\n",
    "men=2\n",
    "transwomen=3\n",
    "transmen=4\n",
    "nonBinary=5\n",
    "other=6\n",
    "\n",
    "print_population_details('all participants', num_data)\n",
    "print_population_details('men participants', num_data[(num_data['Q1.2'] == men)|(num_data['Q1.2'] == transmen)])\n",
    "print_population_details('women participants', num_data[(num_data['Q1.2'] == women)|(num_data['Q1.2'] == transwomen)])\n",
    "print_population_details('cisgender participants', num_data[(num_data['Q1.2'] == women)|(num_data['Q1.2'] == men)])\n",
    "print_population_details('transgender participants', num_data[(num_data['Q1.2'] == transwomen)|(num_data['Q1.2'] == transmen)|(num_data['Q1.2'] == nonBinary)|(num_data['Q1.2'] == other)])\n",
    "\n",
    "\n",
    "# Now let's run some proportion tests\n",
    "print(\"First are men or women more likely to have tried cannabis?\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([463, 77]) # Number of users\n",
    "n_obs = np.array([666, 112]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n",
    "\n",
    "print(\"Now, are men or women more likely to have tried cannabis while programming?\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([241, 77]) # Number of users\n",
    "n_obs = np.array([666, 112]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n",
    "\n",
    "print(\"Finally, are trans or cis participants more likely to have tried cannabis?\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([533, 24]) # Number of users\n",
    "n_obs = np.array([770, 28]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n",
    "\n",
    "print(\"Finally, are trans or cis participants more likely to have tried cannabis while programming?\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([264, 16]) # Number of users\n",
    "n_obs = np.array([770, 28]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now let's look at percent usage of weed and percent usage of weed by gender:\n",
      "Percent of all participants who have tried cannabis: 69.36% (557)\n",
      "Percent of all participants who have tried cannabis while programming: 34.87% (280)\n",
      "Average/Median use frequency of all participants who have tried cannabis: 5.70 6.0 (556)\n",
      "Average/Median use frequency of all participants who have tried cannabis in last year: 7.44 8.0 (421)\n",
      "Average/Median use frequency of all participants who have tried cannabis while programming: 4.65 5.0 (280)\n",
      "Average/Median use frequency of all participants who have tried cannabis while programming in last year: 6.74 6.0 (188)\n",
      "\n",
      "Percent of men participants who have tried cannabis: 69.52% (463)\n",
      "Percent of men participants who have tried cannabis while programming: 36.19% (241)\n",
      "Average/Median use frequency of men participants who have tried cannabis: 5.67 6.0 (462)\n",
      "Average/Median use frequency of men participants who have tried cannabis in last year: 7.47 8.0 (346)\n",
      "Average/Median use frequency of men participants who have tried cannabis while programming: 4.70 5.0 (241)\n",
      "Average/Median use frequency of men participants who have tried cannabis while programming in last year: 6.88 7.0 (160)\n",
      "\n",
      "Percent of women participants who have tried cannabis: 68.75% (77)\n",
      "Percent of women participants who have tried cannabis while programming: 25.00% (28)\n",
      "Average/Median use frequency of women participants who have tried cannabis: 5.58 6.0 (77)\n",
      "Average/Median use frequency of women participants who have tried cannabis in last year: 6.97 7.0 (61)\n",
      "Average/Median use frequency of women participants who have tried cannabis while programming: 4.86 4.5 (28)\n",
      "Average/Median use frequency of women participants who have tried cannabis while programming in last year: 5.91 6.0 (23)\n",
      "\n",
      "Percent of cisgender participants who have tried cannabis: 69.22% (533)\n",
      "Percent of cisgender participants who have tried cannabis while programming: 34.29% (264)\n",
      "Average/Median use frequency of cisgender participants who have tried cannabis: 5.64 6.0 (532)\n",
      "Average/Median use frequency of cisgender participants who have tried cannabis in last year: 7.39 8.0 (401)\n",
      "Average/Median use frequency of cisgender participants who have tried cannabis while programming: 4.71 5.0 (264)\n",
      "Average/Median use frequency of cisgender participants who have tried cannabis while programming in last year: 6.73 6.0 (180)\n",
      "\n",
      "Percent of transgender participants who have tried cannabis: 85.71% (24)\n",
      "Percent of transgender participants who have tried cannabis while programming: 57.14% (16)\n",
      "Average/Median use frequency of transgender participants who have tried cannabis: 7.00 7.0 (24)\n",
      "Average/Median use frequency of transgender participants who have tried cannabis in last year: 8.40 8.5 (20)\n",
      "Average/Median use frequency of transgender participants who have tried cannabis while programming: 3.62 3.0 (16)\n",
      "Average/Median use frequency of transgender participants who have tried cannabis while programming in last year: 7.00 6.0 (8)\n",
      "\n",
      "First are men or women more likely to have tried cannabis?\n",
      "Test type: <class 'tuple'>, p = 8.701e-01, stat = 0.164\n",
      "\n",
      "Now, are men or women more likely to have tried cannabis while programming?\n",
      "Test type: <class 'tuple'>, p = 8.813e-11, stat = -6.486\n",
      "\n",
      "Finally, are trans or cis participants more likely to have tried cannabis?\n",
      "Test type: <class 'tuple'>, p = 6.187e-02, stat = -1.867\n",
      "\n",
      "Finally, are trans or cis participants more likely to have tried cannabis while programming?\n",
      "Test type: <class 'tuple'>, p = 1.279e-02, stat = -2.489\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "source": [
    "# Let's correct RQ1 for multpile comparisons - Benjamini–Hochberg (https://www.statisticshowto.com/benjamini-hochberg-procedure/)\n",
    "\n",
    "print(\"Correcting for Multiple Comparisons for all statistical tests in RQ1. The True the farthest in this list means that all above it pass the threshold\")\n",
    "\n",
    "p_values = [8.813e-11, # men more likely to have tried cannabis while programming\n",
    "            1.429e-03, # GitHub participants more likely to have tried cannabis while programming?\n",
    "            0.00259, # Correlation between age and cannabis use\n",
    "            1.279e-02, # Trans more likely than cis to have tried cannabis while programming\n",
    "            6.187e-02, # Trans cs cis trying cannabis\n",
    "            6.557e-02, # Github vs uni trying cannabis\n",
    "            8.701e-01 # Women vs men trying cannabis\n",
    "            ]\n",
    "print(benjamini_hochberg(p_values, 0.05))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Correcting for Multiple Comparisons for all statistical tests in RQ1. The True the farthest in this list means that all above it pass the threshold\n",
      "[(8.813e-11, 1, 0.007142857142857143, True), (0.001429, 2, 0.014285714285714285, True), (0.00259, 3, 0.02142857142857143, True), (0.01279, 4, 0.02857142857142857, True), (0.06187, 5, 0.03571428571428572, False), (0.06557, 6, 0.04285714285714286, False), (0.8701, 7, 0.05, False)]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# RQ2: Programming use context\n",
    "\n",
    "This question investigates the context of when programmers use cannabis. Specifically, we investigate in terms of programming project context, software engineering task context, and remote work"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "source": [
    "print(\"Now let's look at when people use cannabis while programming\")\n",
    "\n",
    "def build_boolean_for_job_type(in_df):\n",
    "    return ((in_df['Q6.08_1']==1)\n",
    "        |(in_df['Q6.08_2']==1)\n",
    "        |(in_df['Q6.08_3']==1)\n",
    "        |(in_df['Q6.08_4']==1)\n",
    "        |(in_df['Q6.08_5']==1)\n",
    "        |(in_df['Q6.08_6']==1)\n",
    "        |(in_df['Q6.08_0']==1))\n",
    "\n",
    "# First get the columns relevant for this analysis:\n",
    "needed_cols = [col for col in num_data if col.startswith('Q6.08')]\n",
    "reasons_all = num_data[needed_cols]\n",
    "reasons_cannabis = reasons_all[(reasons_all['Q6.08_1']==1)|(reasons_all['Q6.08_1']==-99.0)]\n",
    "reasons_checked_at_least_one = reasons_all[build_boolean_for_job_type(reasons_all)]\n",
    "reasons_checked_at_least_one_github = git_responses[needed_cols][build_boolean_for_job_type(git_responses)]\n",
    "reasons_checked_at_least_one_umich = umich_responses[needed_cols][build_boolean_for_job_type(umich_responses)]\n",
    "\n",
    "\n",
    "col_lab_map = {\n",
    "                'Q6.08_1': [0,\"school-related programming tasks\"],\n",
    "                'Q6.08_2': [0,\"work-related programming tasks\"],\n",
    "                'Q6.08_3': [0,\"personal programming projects\"],\n",
    "                'Q6.08_4': [0,\"deadline-critical programming tasks\"],\n",
    "                'Q6.08_5': [0,\"non-urgent programming tasks\"],\n",
    "                'Q6.08_6': [0,\"I would use cannabis while programming, but my current workplace forbids it\"],\n",
    "                'Q6.08_0': [0,\"I do not currently use cannabis while programming\"]\n",
    "            }\n",
    "this_df = reasons_checked_at_least_one\n",
    "results = [[this_df[col].value_counts()[1], len(this_df), col_lab_map[col]] for col in reasons_all]\n",
    "\n",
    "# sort these from low to high\n",
    "results.sort(reverse=True)\n",
    "\n",
    "print(\"calculating for all responses:\")\n",
    "print(\"{0:60} {1:5} {2}\".format(\"Label\",  \"Count\", \"Percent\"))\n",
    "for result in results:\n",
    "    print(\"{0:60} {1:5} {2:>7.2f}\".format(result[2][1], result[0], result[0]/result[1]*100))\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now let's look at when people use cannabis while programming\n",
      "calculating for all responses:\n",
      "Label                                                        Count Percent\n",
      "personal programming projects                                  175   62.95\n",
      "non-urgent programming tasks                                   133   47.84\n",
      "work-related programming tasks                                  95   34.17\n",
      "school-related programming tasks                                76   27.34\n",
      "I do not currently use cannabis while programming               63   22.66\n",
      "deadline-critical programming tasks                             25    8.99\n",
      "I would use cannabis while programming, but my current workplace forbids it     5    1.80\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "source": [
    "# Stacked box polt on what type of tasks do they use cannabis for\n",
    "#Q6.10\n",
    "col_lab_map = {\n",
    "                'Q6.10_1': \"An imminent deadline\",\n",
    "                'Q6.10_2': \"Stuck on hard problem\",\n",
    "                'Q6.10_3': \"Architectural Design\",\n",
    "                'Q6.10_4': \"Brainstorming\",\n",
    "                'Q6.10_5': \"Data Analysis\",\n",
    "                'Q6.10_6': \"Detailed Program Design\",\n",
    "                'Q6.10_7': \"Debugging\",\n",
    "                'Q6.10_8': \"Prototyping\",\n",
    "                'Q6.10_9': \"Quality Assurance\",\n",
    "                'Q6.10_10': \"Reading/Writing Docs\",\n",
    "                'Q6.10_11': \"Refactoring\",\n",
    "                'Q6.10_12': \"Requirements Elicitation\",\n",
    "                'Q6.10_13': \"Software Coding/Testing\",\n",
    "                'Q6.10_14': \"System Integration\"\n",
    "}\n",
    "\n",
    "\n",
    "needed_cols = [col for col in num_data if col.startswith('Q6.10')]\n",
    "likert_results = []\n",
    "for col in needed_cols:\n",
    "    avg = num_data[num_data[col] > -99][col].mean()\n",
    "    values = num_data[num_data[col] > -99][col].value_counts()\n",
    "    likert_results.append([values[-1], values[-1]/sum(values)*100, values[0]/sum(values)*100, values[1]/sum(values)*100, col_lab_map[col] + '\\n(' + str(round((values[0] + values[1])/sum(values)*100, 1)) + '%)'])\n",
    "\n",
    "likert_results.sort(reverse=True)\n",
    "\n",
    "less_likely = [x[1] for x in likert_results]\n",
    "nuteral = [x[2] for x in likert_results]\n",
    "more_likely = [x[3] for x in likert_results]\n",
    "labels = [x[4] for x in likert_results]\n",
    "Groups = np.array([less_likely, nuteral, more_likely])\n",
    "Colors = ['#BA325B' , '0.8', '#325BBA']\n",
    "plt.figure(figsize=(7,10))\n",
    "\n",
    "Pos = range(14)\n",
    "for i in range(len(Groups)):\n",
    "    plt.barh(Pos, Groups[i], left = np.sum(Groups[:i], axis = 0), color = Colors[i], edgecolor = 'black')\n",
    "    \n",
    "plt.yticks(Pos, labels)\n",
    "\n",
    "#plt.rcParams[\"figure.figsize\"] = (4,15)\n",
    "plt.xlabel(\"(less likely)   Cumulative Percentage   (more likely)\", fontdict={'size': 12})\n",
    "plt.title('Responses for \"I am ______ likely to use cannabis \\nwhen working on\":', fontdict={'size': 14})\n",
    "plt.legend(['Less likely', 'Neutral', 'More likely'], title = 'Response Choice', loc = 'best', bbox_to_anchor=(0.857, -0.07), ncol=3)\n",
    "plt.show() \n",
    "#plt.rcParams[\"figure.figsize\"] = plt.rcParamsDefault[\"figure.figsize\"]\n"
   ],
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 504x720 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "source": [
    "print(\"Now let's look at percent usage of weed and percent usage of weed plus covid:\")\n",
    "\n",
    "#Q5.1: Have you ever used cannabis\n",
    "#Q5.3: Average frequency for using cannabis\n",
    "#Q6.01: Have you ever used cannabis while programming\n",
    "#Q6.03: Cannabis usage pattern by frequency\n",
    "# FIXME - add both requency of use ant form of cannabis to all of the above\n",
    "print(\"More or less likely to use cannabis while programming post covid: - is less, + is more\")\n",
    "print(num_data['Q6.06'].value_counts())\n",
    "\n",
    "print(\"Ok - let's do a statistical test for that last one (combind negative proportion vs combined positive proportion)\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([82, 27]) # Number of users\n",
    "n_obs = np.array([280, 280]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n",
    "\n",
    "\n",
    "print(\"More or less likely to use cannabis while working from home: - is less, + is more\")\n",
    "print(num_data['Q6.07'].value_counts())\n",
    "\n",
    "print(\"Ok - let's do a statistical test for that last one (combind negative proportion vs combined positive proportion)\")\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "count = np.array([145, 13]) # Number of users\n",
    "n_obs = np.array([280, 280]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, n_obs))\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now let's look at percent usage of weed and percent usage of weed plus covid:\n",
      "More or less likely to use cannabis while programming post covid: - is less, + is more\n",
      " 0.0     170\n",
      " 1.0      64\n",
      " 2.0      18\n",
      "-2.0      14\n",
      "-1.0      13\n",
      "-99.0      2\n",
      "Name: Q6.06, dtype: int64\n",
      "Ok - let's do a statistical test for that last one (combind negative proportion vs combined positive proportion)\n",
      "Test type: <class 'tuple'>, p = 4.352e-09, stat = 5.870\n",
      "\n",
      "More or less likely to use cannabis while working from home: - is less, + is more\n",
      " 0.0     121\n",
      " 1.0      89\n",
      " 2.0      56\n",
      "-2.0       8\n",
      "-1.0       5\n",
      "-99.0      2\n",
      "Name: Q6.07, dtype: int64\n",
      "Ok - let's do a statistical test for that last one (combind negative proportion vs combined positive proportion)\n",
      "Test type: <class 'tuple'>, p = 2.801e-35, stat = 12.394\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "source": [
    "# Let's correct RQ1 for multpile comparisons - Benjamini–Hochberg (https://www.statisticshowto.com/benjamini-hochberg-procedure/)\n",
    "\n",
    "print(\"Correcting for Multiple Comparisons for all statistical tests in RQ2. The True the farthest in this list means that all above it pass the threshold\")\n",
    "\n",
    "p_values = [2.801e-35, # remote work\n",
    "            4.352e-09 # covid\n",
    "            ]\n",
    "print(benjamini_hochberg(p_values, 0.05))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Correcting for Multiple Comparisons for all statistical tests in RQ2. The True the farthest in this list means that all above it pass the threshold\n",
      "[(2.801e-35, 1, 0.025, True), (4.352e-09, 2, 0.05, True)]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# RQ3: Motivation for using cannabis while programming\n",
    "\n",
    "Answers to question Q6.09: \"Why do you use cannabis while programming, coding, or completing other software engineering-related tasks? [select all that apply]\"\n",
    "\n",
    "Possible Answers:\n",
    "\n",
    "1) Wellbeing: To mitigate programming-related or programming-enhanced pain (e.g. back or wrist pain)\n",
    "2) Wellbeing: To help with work-related or work-enhanced anxiety\n",
    "3) Wellbeing: To help with work-related or work-enhanced social anxiety\n",
    "4) Wellbeing: To help with work-related or work-enhanced migraines (e.g. screen fatigue)\n",
    "5) Enjoyment: To make programming-related tasks more enjoyable\n",
    "6) Help Programming: To think of more creative programming solutions\n",
    "7) Help Programming: To gain insight or understanding\n",
    "8) Help Programming: To enhance brainstorming\n",
    "9) Help Programming: To focus on programming-related tasks\n",
    "10) Help Programming: To get in a programming zone\n",
    "11) Enjoyment: To make programming-related tasks less tedious\n",
    "12) Enjoyment: To improve social interactions in the workplace\n",
    "13) Enjoyment: To have fun in social programming settings\n",
    "14) Wellbeing: I am unable to think as clearly without cannabis\n",
    "15) Wellbeing: For non-programming related medical conditions\n",
    "16) Other (please describe)\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "source": [
    "\n",
    "def build_boolean(in_df):\n",
    "    return ((in_df['Q6.09_1']==1)\n",
    "        |(in_df['Q6.09_2']==1)\n",
    "        |(in_df['Q6.09_3']==1)\n",
    "        |(in_df['Q6.09_4']==1)\n",
    "        |(in_df['Q6.09_5']==1)\n",
    "        |(in_df['Q6.09_6']==1)\n",
    "        |(in_df['Q6.09_7']==1)\n",
    "        |(in_df['Q6.09_8']==1)\n",
    "        |(in_df['Q6.09_9']==1)\n",
    "        |(in_df['Q6.09_10']==1)\n",
    "        |(in_df['Q6.09_11']==1)\n",
    "        |(in_df['Q6.09_12']==1)\n",
    "        |(in_df['Q6.09_13']==1)\n",
    "        |(in_df['Q6.09_14']==1)\n",
    "        |(in_df['Q6.09_15']==1)\n",
    "        |(in_df['Q6.09_16']==1))\n",
    "\n",
    "# First get the columns relevant for this analysis:\n",
    "needed_cols = [col for col in num_data if col.startswith('Q6.09')]\n",
    "reasons_all = num_data[needed_cols]\n",
    "reasons_cannabis = reasons_all[(reasons_all['Q6.09_1']==1)|(reasons_all['Q6.09_1']==-99.0)]\n",
    "reasons_checked_at_least_one = reasons_all[build_boolean(reasons_all)]\n",
    "reasons_checked_at_least_one_github = git_responses[needed_cols][build_boolean(git_responses)]\n",
    "reasons_checked_at_least_one_umich = umich_responses[needed_cols][build_boolean(umich_responses)]\n",
    "\n",
    "\n",
    "col_lab_map = {\n",
    "                'Q6.09_1': [0,\"To mitigate programming-related or programming-enhanced pain (e.g. back or wrist pain)\"],\n",
    "                'Q6.09_2': [0,\"To help with work-related or work-enhanced anxiety\"],\n",
    "                'Q6.09_3': [0,\"To help with work-related or work-enhanced social anxiety\"],\n",
    "                'Q6.09_4': [0,\"To help with work-related or work-enhanced migraines (e.g. screen fatigue)\"],\n",
    "                'Q6.09_5': [1,\"To make programming-related tasks more enjoyable\"],\n",
    "                'Q6.09_6': [2,\"To think of more creative programming solutions\"],\n",
    "                'Q6.09_7': [2,\"To gain insight or understanding\"],\n",
    "                'Q6.09_8': [2,\"To enhance brainstorming\"],\n",
    "                'Q6.09_9': [2,\"To focus on programming-related tasks\"],\n",
    "                'Q6.09_10': [2,\"To get in a programming zone\"],\n",
    "                'Q6.09_11': [1,\"To make programming-related tasks less tedious\"],\n",
    "                'Q6.09_12': [1,\"To improve social interactions in the workplace\"],\n",
    "                'Q6.09_13': [1,\"To have fun in social programming settings\"],\n",
    "                'Q6.09_14': [0,\"I am unable to think as clearly without cannabis\"],\n",
    "                'Q6.09_15': [0,\"For non-programming related medical conditions\"],\n",
    "                'Q6.09_16': [3,\"Other (please describe)\"]\n",
    "            }\n",
    "\n",
    "catategories = [\"Wellness\", \"Enjoyment\", \"Programming\", \"Other\"]\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "source": [
    "# Now, calculate the percentages of those who clicked it for each one for\n",
    "this_df = reasons_checked_at_least_one\n",
    "results = [[this_df[col].value_counts()[1], len(this_df), col_lab_map[col]] for col in reasons_all]\n",
    "\n",
    "# sort these from low to high\n",
    "results.sort(reverse=True)\n",
    "\n",
    "print(\"calculating for all responses:\")\n",
    "print(\"{0:90} {1:15} {2:5} {3}\".format(\"Label\", \"Category\", \"Count\", \"Percent\"))\n",
    "for result in results:\n",
    "    print(\"{0:90} {1:<15} {2:5} {3:>7.2f}\".format(result[2][1], catategories[result[2][0]], result[0], result[0]/result[1]*100))\n",
    "\n",
    "\n",
    "this_df = reasons_checked_at_least_one_github\n",
    "results = [[this_df[col].value_counts()[1], len(this_df), col_lab_map[col]] for col in reasons_all]\n",
    "\n",
    "# sort these from low to high\n",
    "results.sort(reverse=True)\n",
    "print(\"\\ncalculating for just open source responses:\")\n",
    "print(\"{0:90} {1:15} {2:5} {3}\".format(\"Label\", \"Category\", \"Count\", \"Percent\"))\n",
    "for result in results:\n",
    "    print(\"{0:90} {1:<15} {2:5} {3:>7.2f}\".format(result[2][1], catategories[result[2][0]], result[0], result[0]/result[1]*100))\n",
    "\n",
    "this_df = reasons_checked_at_least_one_umich\n",
    "results = [[0 if len(this_df[col].value_counts()) == 1 else this_df[col].value_counts()[1], len(this_df), col_lab_map[col]] for col in reasons_all]\n",
    "\n",
    "# sort these from low to high\n",
    "results.sort(reverse=True)\n",
    "print(\"\\ncalculating for just umich responses:\")\n",
    "print(\"{0:90} {1:15} {2:5} {3}\".format(\"Label\", \"Category\", \"Count\", \"Percent\"))\n",
    "for result in results:\n",
    "    print(\"{0:90} {1:<15} {2:5} {3:>7.2f}\".format(result[2][1], catategories[result[2][0]], result[0], result[0]/result[1]*100))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "calculating for all responses:\n",
      "Label                                                                                      Category        Count Percent\n",
      "To make programming-related tasks more enjoyable                                           Enjoyment         148   60.91\n",
      "To think of more creative programming solutions                                            Programming       128   52.67\n",
      "To get in a programming zone                                                               Programming       117   48.15\n",
      "To make programming-related tasks less tedious                                             Enjoyment         103   42.39\n",
      "To enhance brainstorming                                                                   Programming        96   39.51\n",
      "To focus on programming-related tasks                                                      Programming        80   32.92\n",
      "To gain insight or understanding                                                           Programming        79   32.51\n",
      "To help with work-related or work-enhanced anxiety                                         Wellness           67   27.57\n",
      "To have fun in social programming settings                                                 Enjoyment          35   14.40\n",
      "Other (please describe)                                                                    Other              33   13.58\n",
      "To mitigate programming-related or programming-enhanced pain (e.g. back or wrist pain)     Wellness           32   13.17\n",
      "To help with work-related or work-enhanced social anxiety                                  Wellness           32   13.17\n",
      "To improve social interactions in the workplace                                            Enjoyment          18    7.41\n",
      "For non-programming related medical conditions                                             Wellness           17    7.00\n",
      "To help with work-related or work-enhanced migraines (e.g. screen fatigue)                 Wellness           12    4.94\n",
      "I am unable to think as clearly without cannabis                                           Wellness           11    4.53\n",
      "\n",
      "calculating for just open source responses:\n",
      "Label                                                                                      Category        Count Percent\n",
      "To make programming-related tasks more enjoyable                                           Enjoyment          79   54.11\n",
      "To think of more creative programming solutions                                            Programming        74   50.68\n",
      "To get in a programming zone                                                               Programming        67   45.89\n",
      "To make programming-related tasks less tedious                                             Enjoyment          54   36.99\n",
      "To focus on programming-related tasks                                                      Programming        50   34.25\n",
      "To enhance brainstorming                                                                   Programming        48   32.88\n",
      "To gain insight or understanding                                                           Programming        42   28.77\n",
      "To help with work-related or work-enhanced anxiety                                         Wellness           32   21.92\n",
      "Other (please describe)                                                                    Other              25   17.12\n",
      "To have fun in social programming settings                                                 Enjoyment          22   15.07\n",
      "To help with work-related or work-enhanced social anxiety                                  Wellness           18   12.33\n",
      "To improve social interactions in the workplace                                            Enjoyment          17   11.64\n",
      "To mitigate programming-related or programming-enhanced pain (e.g. back or wrist pain)     Wellness           17   11.64\n",
      "For non-programming related medical conditions                                             Wellness           13    8.90\n",
      "To help with work-related or work-enhanced migraines (e.g. screen fatigue)                 Wellness            8    5.48\n",
      "I am unable to think as clearly without cannabis                                           Wellness            8    5.48\n",
      "\n",
      "calculating for just umich responses:\n",
      "Label                                                                                      Category        Count Percent\n",
      "To make programming-related tasks more enjoyable                                           Enjoyment          61   71.76\n",
      "To think of more creative programming solutions                                            Programming        49   57.65\n",
      "To get in a programming zone                                                               Programming        44   51.76\n",
      "To make programming-related tasks less tedious                                             Enjoyment          44   51.76\n",
      "To enhance brainstorming                                                                   Programming        43   50.59\n",
      "To gain insight or understanding                                                           Programming        32   37.65\n",
      "To help with work-related or work-enhanced anxiety                                         Wellness           31   36.47\n",
      "To focus on programming-related tasks                                                      Programming        27   31.76\n",
      "To mitigate programming-related or programming-enhanced pain (e.g. back or wrist pain)     Wellness           14   16.47\n",
      "To have fun in social programming settings                                                 Enjoyment          12   14.12\n",
      "To help with work-related or work-enhanced social anxiety                                  Wellness           12   14.12\n",
      "Other (please describe)                                                                    Other               8    9.41\n",
      "To help with work-related or work-enhanced migraines (e.g. screen fatigue)                 Wellness            4    4.71\n",
      "For non-programming related medical conditions                                             Wellness            4    4.71\n",
      "I am unable to think as clearly without cannabis                                           Wellness            2    2.35\n",
      "To improve social interactions in the workplace                                            Enjoyment           0    0.00\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# RQ4: How about perceptions of cannabis use?\n",
    "\n",
    "Answers to question Q6.09: \"Why do you use cannabis while programming, coding, or completing other software engineering-related tasks? [select all that apply]\"\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "source": [
    "# First, we'll get the subsets of data that are important between managers, employees, and students\n",
    "\n",
    "# Current programming-related employees that are not managers\n",
    "# And have a manager\n",
    "df_non_manager_employees_with_manager = num_data[(num_data['Q2.18'] == -1)&(num_data['Q2.18b'] == 1)&(num_data['Q2.14'] == 1)] \n",
    "\n",
    "# Anyone who has ever had a programming-related job\n",
    "df_all_who_have_worked = num_data[num_data['Q2.10'] == 1]\n",
    "\n",
    "# Anyone who currently has a programming-related job\n",
    "df_all_who_are_working_now = num_data[num_data['Q2.14'] == 1] \n",
    "\n",
    "all_who_are_students = num_data[num_data['Q1.5_3'] == 1]\n",
    "all_who_are_full_time_employees = num_data[num_data['Q1.5_4'] == 1]\n",
    "all_who_are_part_time_employees = num_data[num_data['Q1.5_5'] == 1]\n",
    "all_who_are_self_employed = num_data[num_data['Q1.5_7'] == 1]\n",
    "\n",
    "\n",
    "# Those who currently have a programming-related job: includes part-time, full-time, self-employed\n",
    "df_current_workers = num_data[((num_data['Q1.5_4'] == 1)|(num_data['Q1.5_5'] == 1)|(num_data['Q1.5_7'] == 1))&(num_data['Q2.14'] == 1)]\n",
    "\n",
    "#Those who are current programming managers:\n",
    "df_managers = df_current_workers[(df_current_workers['Q2.18'] == 1)]\n",
    "\n",
    "# Those who are programming employees but not currently managers\n",
    "df_non_manager_employees = df_current_workers[(df_current_workers['Q2.18'] == -1)]\n",
    "\n",
    "# Those who are programming workers and also not currently students\n",
    "df_non_student_professionals = df_current_workers[(df_current_workers['Q1.5_3'] != 1)|((df_current_workers['Q1.5_3'] == 1)&(df_current_workers['Q2.8_7'] == 1))] # Where not a programming-related student\n",
    "\n",
    "# Those who are current students in a programming-related field\n",
    "df_current_programming_students = num_data[(num_data['Q2.8_1'] == 1)|(num_data['Q2.8_2'] == 1)|(num_data['Q2.8_3'] == 1)|(num_data['Q2.8_4'] == 1)|(num_data['Q2.8_5'] == 1)|(num_data['Q2.8_6'] == 1)]\n",
    "\n",
    "print(\"All who currently have a programming-related job (full-time, part-time, self-employeed)\", df_current_workers.shape) \n",
    "print(\"All those with a current programming job who are currently managers\", df_managers.shape)\n",
    "print(\"Current programming employees non-managers\", df_non_manager_employees.shape)\n",
    "print(\"Current programming professionals who are not students\", df_non_student_professionals.shape) # Those who are programming-related employees who are not programming related students\n",
    "print(\"Current programming students:\", df_current_programming_students.shape)\n",
    "\n",
    "print(\"\\n\\nAll who have had programming-related job:\", df_all_who_have_worked.shape)\n",
    "print(\"Currently students:\", all_who_are_students.shape)\n",
    "print(\"Currently full-time employees:\", all_who_are_full_time_employees.shape)\n",
    "print(\"Currently part-time employees:\", all_who_are_part_time_employees.shape)\n",
    "print(\"Currently self employees:\", all_who_are_self_employed.shape)\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "All who currently have a programming-related job (full-time, part-time, self-employeed) (520, 376)\n",
      "All those with a current programming job who are currently managers (190, 376)\n",
      "Current programming employees non-managers (330, 376)\n",
      "Current programming professionals who are not students (476, 376)\n",
      "Current programming students: (237, 376)\n",
      "\n",
      "\n",
      "All who have had programming-related job: (684, 376)\n",
      "Currently students: (290, 376)\n",
      "Currently full-time employees: (464, 376)\n",
      "Currently part-time employees: (86, 376)\n",
      "Currently self employees: (45, 376)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "source": [
    "# Now, let's look at the perception differences between the groups - let's start with managers and employees\n",
    "\n",
    "print(\"Now on to different attitudes about weed and programming in particular\")\n",
    "\n",
    "# Q4.5 is disaprove of a collegue or teammate - not asked to managers\n",
    "# Q4.6 is what do you think your manager would think? Only to employees - not asked to managers\n",
    "# Q4.7 As a manager, would you disaprove if your employee....\n",
    " \n",
    "df_4p5 = df_non_manager_employees[(df_non_manager_employees['Q4.5_1']!=-99)&(df_non_manager_employees['Q4.5_2']!=-99)&(df_non_manager_employees['Q4.5_3']!=-99)&(df_non_manager_employees['Q4.5_4']!=-99)]\n",
    "score_4p5 = df_4p5[['Q4.5_1', 'Q4.5_2', 'Q4.5_3', 'Q4.5_4']].mean(axis=1)\n",
    "\n",
    "df_4p6 = df_non_manager_employees[(df_non_manager_employees['Q4.6_1']!=-99)&(df_non_manager_employees['Q4.6_2']!=-99)&(df_non_manager_employees['Q4.6_3']!=-99)&(df_non_manager_employees['Q4.6_4']!=-99)]\n",
    "score_4p6 = df_4p6[['Q4.6_1', 'Q4.6_2', 'Q4.6_3', 'Q4.6_4']].mean(axis=1)\n",
    "\n",
    "df_4p7 = df_managers[(df_managers['Q4.7_1']!=-99)&(df_managers['Q4.7_2']!=-99)&(df_managers['Q4.7_3']!=-99)&(df_managers['Q4.7_4']!=-99)]\n",
    "score_4p7 = df_4p7[['Q4.7_1', 'Q4.7_2', 'Q4.7_3', 'Q4.7_4']].mean(axis=1)\n",
    "\n",
    "\n",
    "print(\"Are managers more positive on weed than employees think they would be? Answer - yes\\n\")\n",
    "summary_statistics((\"Managers thoughts on employees\", score_4p7), (\"What employees think managers think\", score_4p6))\n",
    "print_t_test_result(ttest_ind(score_4p7, score_4p6, equal_var=False, alternative='two-sided', nan_policy='omit'))\n",
    "\n",
    "print(\"Do managers disaprove more about weed use by their employess than employees do of their collegues?\\n\")\n",
    "summary_statistics((\"Managers thoughts on employees\", score_4p7), (\"Employees on collegues\", score_4p5))\n",
    "print_t_test_result(ttest_ind(score_4p7, score_4p5, equal_var=False, alternative='two-sided', nan_policy='omit'))\n",
    "\n",
    "print(\"For a final difference between manager and employee perceptions - how likely are you to know someone at your workplace that uses weed?\")\n",
    "\n",
    "#Q4.10: Do you know a collegue at your current workplace who uses it on the job?\n",
    "#Q4.11: Do you know a manager at your current workplace who uses it on the job?\n",
    "\n",
    "know_coll = df_current_workers[df_current_workers['Q4.10']!=-99]['Q4.10']\n",
    "know_manager = df_current_workers[df_current_workers['Q4.11']!=-99]['Q4.11']\n",
    "print(know_coll.value_counts())\n",
    "print(know_manager.value_counts())\n",
    "summary_statistics((\"Do you know a collegue who uses\", know_coll), (\"Do you know a manager who uses\", know_manager))\n",
    "print_t_test_result(ttest_ind(know_coll, know_manager, equal_var=False, alternative='two-sided'))\n",
    "\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now on to different attitudes about weed and programming in particular\n",
      "Are managers more positive on weed than employees think they would be? Answer - yes\n",
      "\n",
      "Number of Managers thoughts on employees: 189, Number of What employees think managers think: 306\n",
      "Mean of Managers thoughts on employees: -0.512, Mean of What employees think managers think: -1.040\n",
      "Median of Managers thoughts on employees: -0.500, Median of What employees think managers think: -1.000\n",
      "Stdev of Managers thoughts on employees: 0.978, Stdev of What employees think managers think: 0.832\n",
      "Test type: <class 'scipy.stats.mstats_basic.Ttest_indResult'>, p = 1.889e-09, stat = 6.170\n",
      "\n",
      "Do managers disaprove more about weed use by their employess than employees do of their collegues?\n",
      "\n",
      "Number of Managers thoughts on employees: 189, Number of Employees on collegues: 329\n",
      "Mean of Managers thoughts on employees: -0.512, Mean of Employees on collegues: -0.381\n",
      "Median of Managers thoughts on employees: -0.500, Median of Employees on collegues: -0.250\n",
      "Stdev of Managers thoughts on employees: 0.978, Stdev of Employees on collegues: 1.028\n",
      "Test type: <class 'scipy.stats.stats.Ttest_indResult'>, p = 1.524e-01, stat = -1.434\n",
      "\n",
      "For a final difference between manager and employee perceptions - how likely are you to know someone at your workplace that uses weed?\n",
      "-1.0    202\n",
      " 0.0    142\n",
      " 2.0     68\n",
      "-2.0     57\n",
      " 1.0     50\n",
      "Name: Q4.10, dtype: int64\n",
      "-1.0    230\n",
      " 0.0    138\n",
      "-2.0    107\n",
      " 2.0     24\n",
      " 1.0     20\n",
      "Name: Q4.11, dtype: int64\n",
      "Number of Do you know a collegue who uses: 519, Number of Do you know a manager who uses: 519\n",
      "Mean of Do you know a collegue who uses: -0.250, Mean of Do you know a manager who uses: -0.724\n",
      "Median of Do you know a collegue who uses: 0.000, Median of Do you know a manager who uses: -1.000\n",
      "Stdev of Do you know a collegue who uses: 1.179, Stdev of Do you know a manager who uses: 0.984\n",
      "Test type: <class 'scipy.stats.stats.Ttest_indResult'>, p = 3.729e-12, stat = 7.033\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "source": [
    "# So we found that employees think managers will think less of them than they \n",
    "# disapprove of their colleges, but no signifciant difference of effect on what managers think\n",
    "# Is there any difference in usage between the two groups?\n",
    "\n",
    "print(\"Now for usage differences between managers and employees\\n\")\n",
    "\n",
    "#Q5.1: Have you ever used cannabis\n",
    "#Q5.3: Average frequency for using cannabis\n",
    "#Q6.01: Have you ever used cannabis while programming\n",
    "#Q6.03: Cannabis usage pattern by frequency\n",
    "\n",
    "print(\"First, are managers more likely to have tried weed in general - answer no?\")\n",
    "non_manager_has_used = df_non_manager_employees[df_non_manager_employees['Q5.1']!=-99]['Q5.1']\n",
    "manager_has_used = df_managers[df_managers['Q5.1']!=-99]['Q5.1']\n",
    "summary_statistics((\"Managers\", manager_has_used), (\"Non managers\", non_manager_has_used))\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "m_values = manager_has_used.value_counts()\n",
    "nm_values = non_manager_has_used.value_counts()\n",
    "count = np.array([m_values[1.0], nm_values[1.0]]) # Number of users\n",
    "nobs = np.array([sum(m_values), sum(nm_values)]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, nobs))\n",
    "\n",
    "print(\"Now, are managers who have tried or less likely to have tried weed while programming than employees? - answer = no\")\n",
    "non_manager_has_used = df_non_manager_employees[df_non_manager_employees['Q6.01']!=-99]['Q6.01']\n",
    "manager_has_used = df_managers[df_managers['Q6.01']!=-99]['Q6.01']\n",
    "summary_statistics((\"Managers who have used weed\", manager_has_used), (\"Non managers who have used weed\", non_manager_has_used))\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "m_values = manager_has_used.value_counts()\n",
    "nm_values = non_manager_has_used.value_counts()\n",
    "count = np.array([m_values[1.0], nm_values[1.0]]) # Number of users\n",
    "nobs = np.array([len(manager_has_used), len(non_manager_has_used)]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, nobs))\n",
    "\n",
    "#FIXME: Control for age?\n",
    "print(\"Finally, are managers who have used weed while programming more or less likely to use it while programming in the last year? - answer = no\")\n",
    "managers_frequency = df_managers[df_managers['Q6.03']!=-99]['Q6.03']\n",
    "employees_frequency = df_non_manager_employees[df_non_manager_employees['Q6.03']!=-99]['Q6.03']\n",
    "summary_statistics((\"Managers\", managers_frequency), (\"Employees\", employees_frequency))\n",
    "print_t_test_result(ttest_ind(managers_frequency, employees_frequency, equal_var=True, alternative='two-sided', nan_policy='omit'))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now for usage differences between managers and employees\n",
      "\n",
      "First, are managers more likely to have tried weed in general - answer no?\n",
      "Number of Managers: 190, Number of Non managers: 330\n",
      "Mean of Managers: 0.505, Mean of Non managers: 0.394\n",
      "Median of Managers: 1.000, Median of Non managers: 1.000\n",
      "Stdev of Managers: 0.865, Stdev of Non managers: 0.921\n",
      "Test type: <class 'tuple'>, p = 1.747e-01, stat = 1.357\n",
      "\n",
      "Now, are managers who have tried or less likely to have tried weed while programming than employees? - answer = no\n",
      "Number of Managers who have used weed: 143, Number of Non managers who have used weed: 229\n",
      "Mean of Managers who have used weed: 0.021, Mean of Non managers who have used weed: 0.074\n",
      "Median of Managers who have used weed: 1.000, Median of Non managers who have used weed: 1.000\n",
      "Stdev of Managers who have used weed: 1.003, Stdev of Non managers who have used weed: 0.999\n",
      "Test type: <class 'tuple'>, p = 8.147e-01, stat = 0.234\n",
      "\n",
      "Finally, are managers who have used weed while programming more or less likely to use it while programming in the last year? - answer = no\n",
      "Number of Managers: 73, Number of Employees: 123\n",
      "Mean of Managers: 4.849, Mean of Employees: 4.268\n",
      "Median of Managers: 5.000, Median of Employees: 4.000\n",
      "Stdev of Managers: 4.162, Stdev of Employees: 3.959\n",
      "Test type: <class 'scipy.stats.mstats_basic.Ttest_indResult'>, p = 3.310e-01, stat = 0.974\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "source": [
    "# Now, let's look at perception differences between programming students (both employees and not) \n",
    "# and non-student programming employees\n",
    "\n",
    "print(\"Now on to different perceptions about weed and programming between current programming students and current non-student programming workers\")\n",
    "\n",
    "# Q4.4 student disaprove of abother student\n",
    "# Q4.5 is disaprove of a collegue or teammate - not asked to managers\n",
    " \n",
    "df_4p5 = df_non_student_professionals[(df_non_student_professionals['Q4.5_1']!=-99)&(df_non_student_professionals['Q4.5_2']!=-99)&(df_non_student_professionals['Q4.5_3']!=-99)&(df_non_student_professionals['Q4.5_4']!=-99)]\n",
    "score_4p5 = df_4p5[['Q4.5_1', 'Q4.5_2', 'Q4.5_3', 'Q4.5_4']].mean(axis=1)\n",
    "\n",
    "df_4p4 = df_current_programming_students[(df_current_programming_students['Q4.4_1']!=-99)&(df_current_programming_students['Q4.4_2']!=-99)&(df_current_programming_students['Q4.4_3']!=-99)&(df_current_programming_students['Q4.4_4']!=-99)]\n",
    "score_4p4 = df_4p4[['Q4.4_1', 'Q4.4_2', 'Q4.4_3', 'Q4.4_4']].mean(axis=1)\n",
    "\n",
    "print(\"Are students more positive on other students using weed than employees are on other employees? - answer no\\n\")\n",
    "summary_statistics((\"Students thoughts on students\", score_4p4), (\"Employees on collegues\", score_4p5))\n",
    "print_t_test_result(ttest_ind(score_4p4, score_4p5, equal_var=True, alternative='two-sided', nan_policy='omit'))\n",
    "\n",
    "know_coll = df_non_student_professionals[df_non_student_professionals['Q4.10']!=-99]['Q4.10']\n",
    "know_student = df_current_programming_students[df_current_programming_students['Q4.12']!=-99]['Q4.12']\n",
    "summary_statistics((\"Do you know a collegue who uses\", know_coll), (\"Do you know a student who uses\", know_student))\n",
    "print(know_coll.value_counts())\n",
    "print(know_student.value_counts())\n",
    "print_t_test_result(ttest_ind(know_coll, know_student, equal_var=True, alternative='two-sided'))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now on to different perceptions about weed and programming between current programming students and current non-student programming workers\n",
      "Are students more positive on other students using weed than employees are on other employees? - answer no\n",
      "\n",
      "Number of Students thoughts on students: 237, Number of Employees on collegues: 294\n",
      "Mean of Students thoughts on students: -0.254, Mean of Employees on collegues: -0.355\n",
      "Median of Students thoughts on students: -0.250, Median of Employees on collegues: -0.250\n",
      "Stdev of Students thoughts on students: 1.011, Stdev of Employees on collegues: 1.030\n",
      "Test type: <class 'scipy.stats.mstats_basic.Ttest_indResult'>, p = 2.569e-01, stat = 1.135\n",
      "\n",
      "Number of Do you know a collegue who uses: 475, Number of Do you know a student who uses: 236\n",
      "Mean of Do you know a collegue who uses: -0.242, Mean of Do you know a student who uses: 0.360\n",
      "Median of Do you know a collegue who uses: 0.000, Median of Do you know a student who uses: 0.000\n",
      "Stdev of Do you know a collegue who uses: 1.181, Stdev of Do you know a student who uses: 1.318\n",
      "-1.0    181\n",
      " 0.0    131\n",
      " 2.0     62\n",
      "-2.0     53\n",
      " 1.0     48\n",
      "Name: Q4.10, dtype: int64\n",
      " 2.0    65\n",
      "-1.0    58\n",
      " 1.0    49\n",
      " 0.0    46\n",
      "-2.0    18\n",
      "Name: Q4.12, dtype: int64\n",
      "Test type: <class 'scipy.stats.stats.Ttest_indResult'>, p = 1.239e-09, stat = -6.157\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "source": [
    "# Finally, let's look at usage differences between students and workers\n",
    "print(\"Now for usage differences between current non-student workers and programming students\\n\")\n",
    "\n",
    "#Q5.1: Have you ever used cannabis\n",
    "#Q5.3: Average frequency for using cannabis\n",
    "#Q6.01: Have you ever used cannabis while programming\n",
    "#Q6.03: Cannabis usage pattern by frequency\n",
    "\n",
    "print(\"First, are students more likely to have tried weed in general - no - trend towards less likely?\")\n",
    "workers = df_non_student_professionals[df_non_student_professionals['Q5.1']!=-99]['Q5.1']\n",
    "students = df_current_programming_students[df_current_programming_students['Q5.1']!=-99]['Q5.1']\n",
    "summary_statistics((\"All programming students\", students), (\"All non-student workers\", workers))\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "m_values = students.value_counts()\n",
    "nm_values = workers.value_counts()\n",
    "count = np.array([m_values[1.0], nm_values[1.0]]) # Number of users\n",
    "nobs = np.array([sum(m_values), sum(nm_values)]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, nobs))\n",
    "\n",
    "print(\"Now, are students who have tried weed more or less likely to have tried weed while programming? - answer = they are less likely\")\n",
    "workers_have_used_weed = df_non_student_professionals[df_non_student_professionals['Q6.01']!=-99]['Q6.01']\n",
    "student_has_used = df_current_programming_students[df_current_programming_students['Q6.01']!=-99]['Q6.01']\n",
    "summary_statistics((\"Students who have used weed\", student_has_used), (\"Workers who have used weed\", workers_have_used_weed))\n",
    "# Using n-1 chi squared test which is equivelent to a z-proportions test for a 2x2: https://pubmed.ncbi.nlm.nih.gov/17315184/\n",
    "m_values = student_has_used.value_counts()\n",
    "nm_values = workers_have_used_weed.value_counts()\n",
    "count = np.array([m_values[1.0], nm_values[1.0]]) # Number of users\n",
    "nobs = np.array([len(student_has_used), len(workers_have_used_weed)]) # total number asked\n",
    "print_t_test_result(proportions_ztest(count, nobs))\n",
    "\n",
    "#FIXME: Control for age?\n",
    "print(\"Finally, are students who use weed while programming more or less likely to use it while programming in the last year? - no difference\")\n",
    "student_frequency = df_current_programming_students[df_current_programming_students['Q6.03']!=-99]['Q6.03']\n",
    "workers_frequency = df_non_student_professionals[df_non_student_professionals['Q6.03']!=-99]['Q6.03']\n",
    "summary_statistics((\"Students\", student_frequency), (\"Workers\", workers_frequency))\n",
    "print_t_test_result(ttest_ind(student_frequency, workers_frequency, equal_var=False, alternative='two-sided', nan_policy='omit'))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Now for usage differences between current non-student workers and programming students\n",
      "\n",
      "First, are students more likely to have tried weed in general - no - trend towards less likely?\n",
      "Number of All programming students: 237, Number of All non-student workers: 476\n",
      "Mean of All programming students: 0.325, Mean of All non-student workers: 0.437\n",
      "Median of All programming students: 1.000, Median of All non-student workers: 1.000\n",
      "Stdev of All programming students: 0.948, Stdev of All non-student workers: 0.900\n",
      "Test type: <class 'tuple'>, p = 1.240e-01, stat = -1.538\n",
      "\n",
      "Now, are students who have tried weed more or less likely to have tried weed while programming? - answer = they are less likely\n",
      "Number of Students who have used weed: 157, Number of Workers who have used weed: 341\n",
      "Mean of Students who have used weed: -0.032, Mean of Workers who have used weed: 0.073\n",
      "Median of Students who have used weed: -1.000, Median of Workers who have used weed: 1.000\n",
      "Stdev of Students who have used weed: 1.003, Stdev of Workers who have used weed: 0.999\n",
      "Test type: <class 'tuple'>, p = 9.138e-02, stat = -1.688\n",
      "\n",
      "Finally, are students who use weed while programming more or less likely to use it while programming in the last year? - no difference\n",
      "Number of Students: 76, Number of Workers: 183\n",
      "Mean of Students: 4.776, Mean of Workers: 4.459\n",
      "Median of Students: 5.000, Median of Workers: 4.000\n",
      "Stdev of Students: 3.470, Stdev of Workers: 4.050\n",
      "Test type: <class 'scipy.stats.mstats_basic.Ttest_indResult'>, p = 5.250e-01, stat = 0.637\n",
      "\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "source": [
    "# DRUG TEST STUFF\n",
    "print(\"Number of responders who have had to take a drug test for a programming-related job:\")\n",
    "print(cat_data['Q4.13'].value_counts())\n",
    "\n",
    "print(\"Number of responders to the question asking if their work place has drug policy: 1 means yes, 0 is unsure, 2 is no:\")\n",
    "print(df_all_who_are_working_now['Q4.15'].value_counts())\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Number of responders who have had to take a drug test for a programming-related job:\n",
      "No     572\n",
      "Yes    229\n",
      "-99      2\n",
      "Name: Q4.13, dtype: int64\n",
      "Number of responders to the question asking if their work place has drug policy: 1 means yes, 0 is unsure, 2 is no:\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "NameError",
     "evalue": "name 'df_all_who_are_working_now' is not defined",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-6e94e426fc93>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Number of responders to the question asking if their work place has drug policy: 1 means yes, 0 is unsure, 2 is no:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf_all_who_are_working_now\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Q4.15'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'df_all_who_are_working_now' is not defined"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "# General Cannabis Use Thoughts\n",
    "\n",
    "print(\"First, let's see legalization views in general \\n\")\n",
    "weed_legalization = num_data[num_data['Q4.1']!=-99]['Q4.1']\n",
    "print(weed_legalization.value_counts())\n",
    "\n",
    "print(\"Next, let's check if they have different views on the risk of using weed - answer, no - managers do not more risk\\n\")\n",
    "weed_risk = num_data[num_data['Q4.2']!=-99]['Q4.2']\n",
    "print(weed_risk.value_counts())\n"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "First, let's see legalization views in general \n",
      "\n",
      "2.0    728\n",
      "1.0     57\n",
      "0.0     17\n",
      "Name: Q4.1, dtype: int64\n",
      "Next, let's check if they have different views on the risk of using weed - answer, no - managers do not more risk\n",
      "\n",
      "1.0    401\n",
      "0.0    258\n",
      "2.0    107\n",
      "3.0     37\n",
      "Name: Q4.2, dtype: int64\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "# Let's correct RQ4 for multpile comparisons - Benjamini–Hochberg (https://www.statisticshowto.com/benjamini-hochberg-procedure/)\n",
    "\n",
    "print(\"Correcting for Multiple Comparisons for all statistical tests in RQ4. The True the farthest in this list means that all above it pass the threshold\")\n",
    "\n",
    "p_values = [1.889e-09, # What do employees think their managers will think?\n",
    "            1.524e-01, # What's the ground truth of the above?\n",
    "            3.729e-12, # Visibility between managers and collegues\n",
    "            1.747e-01, # Are managers or employees more or less likley to have tried weed?\n",
    "            8.147e-01, # Managers vs employees - tried weed while programming\n",
    "            3.310e-01, # Managers vs employees - use in the last year\n",
    "            2.569e-01, # Student on student vs employee on employee\n",
    "            1.239e-09, # Student visibility vs employee visibility\n",
    "            1.240e-01, # General cannabis usage difference between employees and students\n",
    "            9.138e-02, # Cannabis usage while programming differences employees vs students\n",
    "            5.250e-01 # Cannabis frequency of use employees vs students\n",
    "]\n",
    "            \n",
    "print(benjamini_hochberg(p_values, 0.05))"
   ],
   "outputs": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.4 64-bit"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}