Is there a trade-off between economic growth and stabilization policy? That is, do
policy changes designed to mitigate the downturns in the business cycle have an effect on long-
run economic growth, either positively or negatively? Support your answer carefully.

Suppose that changes in bank regulations expand the availability of credit cards, so

that people need to hold less cash. Use the money demand and supply diagram in the long run to answer

the following:

a.   How does this event affect the demand for money? (explain with graph + words)

b. If the Bank of Canada does not respond to this event, what will happen to the price level?

c. If the Bank of Canada wants to keep the price level stable, what should it do? (show on graph + explain with words)

For example:

Question: If income changes by $40 billion for each $2.28 billion change in spending, h much will income change by?

Answer:   91   (rounded down from the calculated value of $91.2 billion)

[Not acceptable would be: 91.2, nor $91, nor $91.2, et al.]

For the following five questions, assume the following characteristics of the monetary transmission mechanism:

The money multiplier is 2.33

Interest rates will change by 2.25% for every $75 billion change in the money supply.

Investment will change by $60 billion for every 1.5% change in the interest rate.

Income will change by $15 billion for every $3.8 billion change in investment.

1)Identify the change in income when the Fed does the following:

a. Buys $35 billion in bonds.

b. Buys $18 billion in bonds.

c. Buys $5.5 billion in bonds.

d. Sells $12 billion in bonds.

e. Sells $22 billion in bonds.

Identify what determinant changes and explain how the equilibrium price and equilibrium quantity in a purely competitive market will change given the following situations. Draw the appropriate demand and supply curves showing the change. (Each graph should have an equilibrium point before the impact as well as after; be sure to label all parts of the graphs).

a. Product: oranges – A winter storm freezes 50 % of the fruit on the trees in Florida

b. Product: avocados- A tariff is imposed on the importation of avocados from Mexico while demand remains the same.

c. Product: donuts – consumers desire for donuts decreases and the cost of flour (used to make donuts) increases

The changes in each balance sheet account for Carver Corporation during the year just completed are as follows:

Carver Corporation's income statement for the year just ended shows the following:

The company did not dispose of any property, plant, and equipment, buy any long-term investments, issue any bonds payable, or repurchase any of its own common stock during the year. Carver Corporation uses the direct method to construct its statement of cash flows.

Required:

a. Determine the sales adjusted to the cash basis.

b. Determine the cost of goods sold adjusted to the cash basis.

c. Determine the selling and administrative expenses adjusted to a cash basis.

d. Determine the net cash provided by (used in) operating activities. (Negative amounts should be indicated by a minus sign.)

e. Determine the net cash provided by (used in) investing activities. (Negative amounts should be indicated by a minus sign.)

f. Determine the net cash provided by (used in) financing activities. (Negative amounts should be indicated by a minus sign.)

Between 1945 and 1975, the United States changed in many significant ways. Which of these changes, in your opinion, had the greatest influence on American culture during this period? What is a specific example?

Windows PowerShell

1) Write a PowerShell Script to monitor a file for changes.

2) Write a PowerShell Script to create a user account in a specific OU.

QUESTION 7 A business needs to communicate major procedural changes to their employees. Select the suggestions below that management should use to communicate this change. a. ?It should coerce the employees to accept the change. b. ?It should emphasize the benefits the employees will gain from the change. c. ?It should give the employees monetary compensation in order to accept the change. d. ?It should inform employees directly that they must accept the change.

Changes to Itemized Deduction

Tax reform that affects both individuals and businesses was enacted in December 2017. It’s commonly referred to as the Tax Cuts and Jobs Act, TCJA or simply tax reform. In addition to nearly doubling standard deductions, TCJA changed several itemized deductions that can be claimed on Schedule A, Itemized Deductions.

This means that many individuals who formerly itemized may now find it more beneficial to take the standard deduction. Taxpayers may only do one or the other. They either take the standard deduction or claim itemized deductions.

The tax reform law made the following changes to itemized deductions that can be claimed on Schedule A for 2018.

Limit on overall itemized deductions suspended.

The income-based phase-out of certain itemized deductions does not apply in 2018. This means that some taxpayers may be able to deduct more of their total itemized deductions if their deductions were limited in the past because their income was above certain levels.

Deduction for state and local income, sales and property taxes modified.

A taxpayer’s deduction for state and local income, sales and property taxes is limited to a combined, total deduction. The limit is $10,000 - $5,000 if married filing separately. Anything above this amount is not deductible.

New dollar limit on total qualified residence loan balance.

The date a taxpayer took out their mortgage or home equity loan may also impact the amount of interest they can deduct. If a taxpayer’s loan was originated or was treated as originating on or before Dec. 15, 2017, they may deduct interest on up to $1 million in qualifying debt, or $500,000 for taxpayers who are married filing separately, If the loan originated after that date, the taxpayer may only deduct interest on up to $750,000 in qualifying debt, or $375,000 for taxpayers who are married filing separately. The limits apply to the combined amount of loans used to buy, build or substantially improve the taxpayer’s main home and second home.

Deduction for home equity interest modified.

Interest paid on most home equity loans is not deductible unless the interest is paid on loan proceeds used to buy, build or substantially improve a main home or second home.

For example, interest on a home equity loan used to build an addition to an existing home is typically deductible, while interest on the same loan used to pay personal living expenses, such as credit card debts, is not.
As under prior law, the loan must be secured by the taxpayer’s main home or second home (known as a qualified residence), not exceed the cost of the home and meet other requirements.

Limit for charitable contributions modified.

The limit on the deduction for charitable contributions of cash has increased from 50 percent to 60 percent of a taxpayer’s adjusted gross income. This means that some taxpayers who make large donations to charity may be able to deduct more of what they give this year.

Deduction for casualty and theft losses modified.

A taxpayer’s net personal casualty and theft losses must now be attributable to a federally declared disaster to be deductible.

Miscellaneous itemized deductions suspended.

Previously, when a taxpayer itemized, they could deduct the amount of their miscellaneous itemized deductions that exceeded 2 percent of their adjusted gross income. These expenses are no longer deductible.

This includes unreimbursed employee expenses such as uniforms, union dues and the deduction for business-related meals, entertainment and travel. It also includes deductions for tax preparation fees and investment expenses, such as investment management fees, safe deposit box fees and investment expenses from pass-through entities.

Create an example in which a taxpayer would benefit from itemizing deductions instead of taking the standard deduction. In your example give us the taxpayer's filing status, AGI and list of deductions ( descriptions of the expense and the amount).

The following is coded in C++. Please point out any changes or updates you make to the existing code with comments within the code.

Start with the provided code for the class linkedListType. Be sure to implement search, insert, and delete in support of an unordered list (that code is also provided).

Now, add a new function called insertLast that adds a new item to the END of the list, instead of to the beginning of the list. (Note: the link pointer of the last element of the list is NULL.)

Test your new function in main.

-----------------------------------------------------------------------------------

main.cpp (main driver):

#include 
#include "linkedList.h"
using namespace std;


int main()
{
    linkedListType myLL;
    if(myLL.isEmptyList()){
        cout<<"List is empty"<
----------------------------------------------------------------------

linkedList.h (header file containing declarations):

#ifndef H_LinkedListType
#define H_LinkedListType


#include 
#include 


using namespace std;


//Definition of the node


struct nodeType
{
        int info;
        nodeType *link;
};


//*****************  class linkedListType   ****************


class linkedListType
{
public:
    const linkedListType& operator=
                         (const linkedListType&);
      //Overload the assignment operator.


    void initializeList();
      //Initialize the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    bool isEmptyList() const;
      //Function to determine whether the list is empty.
      //Postcondition: Returns true if the list is empty,
      //               otherwise it returns false.


    void print() const;
      //Function to output the data contained in each node.
      //Postcondition: none


    int length() const;
      //Function to return the number of nodes in the list.
      //Postcondition: The value of count is returned.


    void destroyList();
      //Function to delete all the nodes from the list.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    int front() const;
      //Function to return the first element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the first
      //               element of the list is returned.


    int back() const;
      //Function to return the last element of the list.
      //Precondition: The list must exist and must not be
      //              empty.
      //Postcondition: If the list is empty, the program
      //               terminates; otherwise, the last
      //               element of the list is returned.


    bool search(const int& searchItem);
      //Function to determine whether searchItem is in the list.
      //Postcondition: Returns true if searchItem is in the
      //               list, otherwise the value false is
      //               returned.


    void insert(const int& newItem);
      //Function to insert newItem at the beginning of the list.
      //Postcondition: first points to the new list, newItem is
      //               inserted at the beginning of the list,
      //               last points to the last node in the list,
      //               and count is incremented by 1.




    void deleteNode(const int& deleteItem);
      //Function to delete deleteItem from the list.
      //Postcondition: If found, the node containing
      //               deleteItem is deleted from the list.
      //               first points to the first node, last
      //               points to the last node of the updated
      //               list, and count is decremented by 1.




    linkedListType();
      //Default constructor
      //Initializes the list to an empty state.
      //Postcondition: first = nullptr, last = nullptr,
      //               count = 0;


    linkedListType(const linkedListType& otherList);
      //copy constructor


    ~linkedListType();
      //Destructor
      //Deletes all the nodes from the list.
      //Postcondition: The list object is destroyed.


protected:
    int count;   //variable to store the number of
                 //elements in the list
    nodeType *first; //pointer to the first node of the list
    nodeType *last;  //pointer to the last node of the list


private:
    void copyList(const linkedListType& otherList);
      //Function to make a copy of otherList.
      //Postcondition: A copy of otherList is created and
      //               assigned to this list.
};
#endif

------------------------------------------------------

linkedList.cpp (cpp file containing definitions):

#include "linkedList.h"


bool linkedListType::isEmptyList() const
{
    return (first == nullptr);
}


linkedListType::linkedListType() //default constructor
{
    first = nullptr;
    last = nullptr;
    count = 0;
}


void linkedListType::destroyList()
{
    nodeType *temp;   //pointer to deallocate the memory
                            //occupied by the node
    while (first != nullptr)   //while there are nodes in
    {                          //the list
        temp = first;        //set temp to the current node
        first = first->link; //advance first to the next node
        delete temp;   //deallocate the memory occupied by temp
    }
    last = nullptr; //initialize last to nullptr; first has
               //already been set to nullptr by the while loop
    count = 0;
}


void linkedListType::initializeList()
{
        destroyList(); //if the list has any nodes, delete them
}


void linkedListType::print() const
{
    nodeType *current; //pointer to traverse the list


    current = first;    //set current so that it points to
                        //the first node
    while (current != nullptr) //while more data to print
    {
        cout << current->info << " ";
        current = current->link;
    }
}//end print




int linkedListType::length() const
{
    return count;
}  //end length




int linkedListType::front() const
{
    assert(first != nullptr);


    return first->info; //return the info of the first node
}//end front




int linkedListType::back() const
{
    assert(last != nullptr);


    return last->info; //return the info of the last node
}//end back




void linkedListType::copyList(const linkedListType& otherList)
{
    nodeType *newNode; //pointer to create a node
    nodeType *current; //pointer to traverse the list


    if (first != nullptr) //if the list is nonempty, make it empty
       destroyList();


    if (otherList.first == nullptr) //otherList is empty
    {
        first = nullptr;
        last = nullptr;
        count = 0;
    }
    else
    {
        current = otherList.first; //current points to the
                                   //list to be copied
        count = otherList.count;


            //copy the first node
        first = new nodeType;  //create the node


        first->info = current->info; //copy the info
        first->link = nullptr;        //set the link field of
                                   //the node to nullptr
        last = first;              //make last point to the
                                   //first node
        current = current->link;     //make current point to
                                     //the next node


           //copy the remaining list
        while (current != nullptr)
        {
            newNode = new nodeType;  //create a node
            newNode->info = current->info; //copy the info
            newNode->link = nullptr;       //set the link of
                                        //newNode to nullptr
            last->link = newNode;  //attach newNode after last
            last = newNode;        //make last point to
                                   //the actual last node
            current = current->link;   //make current point
                                       //to the next node
        }//end while
    }//end else
}//end copyList


linkedListType::~linkedListType() //destructor
{
   destroyList();
}//end destructor


linkedListType::linkedListType(const linkedListType& otherList)
{
    first = nullptr;
    copyList(otherList);
}//end copy constructor


         //overload the assignment operator
const linkedListType& linkedListType::operator=(const linkedListType& otherList)
{
    if (this != &otherList) //avoid self-copy
    {
        copyList(otherList);
    }//end else


     return *this;
}


bool search(const int& searchItem){}


void insert(const int& newItem){}


void deleteNode(const int& deleteItem){}

-------------------------------------------------------------

Unordered list function implementation file:

bool linkedListType::search(const int& searchItem)
{
    nodeType *current; //pointer to traverse the list
    bool found = false;
    
    current = first; //set current to point to the first 
                     //node in the list


    while (current != nullptr && !found)    //search the list
        if (current->info == searchItem) //searchItem is found
            found = true;
        else
            current = current->link; //make current point to
                                     //the next node
    return found; 
}//end search




void linkedListType::insert(const int& newItem)
{
    nodeType *newNode; //pointer to create the new node


    newNode = new nodeType; //create the new node


    newNode->info = newItem;    //store the new item in the node
    newNode->link = first;      //insert newNode before first
    first = newNode;            //make first point to the
                                //actual first node
    count++;                    //increment count


    if (last == nullptr)   //if the list was empty, newNode is also 
                        //the last node in the list
        last = newNode;
}//end insert (at front)




void linkedListType::deleteNode(const int& deleteItem)
{
    nodeType *current; //pointer to traverse the list
    nodeType *trailCurrent; //pointer just before current
    bool found;


    if (first == nullptr)    //Case 1; the list is empty. 
        cout << "Cannot delete from an empty list."
             << endl;
    else
    {
        if (first->info == deleteItem) //Case 2 
        {
            current = first;
            first = first->link;
            count--;
            if (first == nullptr)    //the list has only one node
                last = nullptr;
            delete current;
        }
        else //search the list for the node with the given info
        {
            found = false;
            trailCurrent = first;  //set trailCurrent to point
                                   //to the first node
            current = first->link; //set current to point to 
                                   //the second node


            while (current != nullptr && !found)
            {
                if (current->info != deleteItem) 
                {
                    trailCurrent = current;
                    current = current-> link;
                }
                else
                    found = true;
            }//end while


            if (found) //Case 3; if found, delete the node
            {
                trailCurrent->link = current->link;
                count--;


                if (last == current)   //node to be deleted 
                                       //was the last node
                    last = trailCurrent; //update the value 
                                         //of last
                delete current;  //delete the node from the list
            }
            else
                cout << "The item to be deleted is not in "
                     << "the list." << endl;
        }//end else
    }//end else
}//end deleteNode