research – How to analyse results for an open ended question?

I asked an open-ended question in a survey about one of our app’s features (That is somewhat similar to its search feature) to find out why users would use this instead of search. I’ve got a large number of responses (1000+).

My question is what’s a good approach to analyzing the responses and derive insights without having to go through each response. Right now I’m searching for the most frequently used keywords and grouping them. is there another more effective way?

data structures – Why we put restriction on deque(double ended queue)?

The definition of deque says “Deque or Double Ended Queue is a type of queue in which insertion and removal of elements can either be performed from the front or the rear.”

Types of Deque: 1.] Input Restricted Deque: input is restricted at a single end
2.] Output Restricted Deque: output is restricted at a single end

But then why do we put restriction on any one end of deque for insertion/removal, when it is possible to perform both the operations from both the ends ? And then classify them on the basis of this restriction.

unity – How can I check if Animator ended playing specific State animation?

This way it’s getting inside all the time while the animation state is playing :

void Update()
    {
        if (this.animator.GetCurrentAnimatorStateInfo(0).IsName("Stand Up"))
        {
            string tt = "";
        }
    }

So I tried to add ! to check if it false :

void Update()
    {
        if (!this.animator.GetCurrentAnimatorStateInfo(0).IsName("Stand Up"))
        {
            string tt = "";
        }
    }

but this way it’s never getting inside even if the state animation finished playing.

I have one Base Layer in the animator controller.

linked list – Integer Double Ended Queue GO

I’m currently learning Go and I have decided to implement a Circular Doubly Linked List (Deque) structure for the training. Go is not my first language. I program mainly in Python, therefore I would like to learn if code follows Go structure and idioms and if you have any advice of improving.

About the code:

This is circular doubly linked list data structure, so the idea is to have O(1) add/remove/peek access to the elements at the beginning/end of the list and no access to elements between the two. I implemented methods for adding and removing elements and also to represent list as string and compare two lists. deque.test also contains test cases for each of the methods.

I use linked list here, but I acknowledge that same thing can be achieved with slices (maybe more efficiently), but my secondary goal was to get used to pointers and references – as those doesn’t appear in Python.

Question about the code:

I’m hoping for general feedback but I also have questions about specific section:

  • When deque is empty and I’m trying to pop element, method would call panic to stop execution of the program, instead of returning an error. Is this a good practice in Go? Should I return value and error from pop instead (it seems a bit awkward to me to require handling possible empty list error every time an element is popped).

Project Structure

collections/
- cmd/
- - main.go
- deque/
- - deque.go       
- - deque_test.go  
- - node.go
- - test_cases.go
- some_other_collection/
- - ... 

deque.go

// Package deque implements deque type and common methods to interact with
// deque.
package deque

import (
    "strconv"
    "strings"
)

// Deque is implemented as circular doubly linked list with sentinel node.
// This allows for O(1) non-amortized add/remove operations for both ends
// of the structure. This makes it a perfect implementation of queue data
// structure.
type Deque struct {
    sentinel *IntNode
    length   int
}

// Constructor for new empty deque.
func New() Deque {
    sentinel := &IntNode{0, nil, nil}
    sentinel.prev = sentinel
    sentinel.next = sentinel
    return Deque{sentinel, 0}
}

// Constructor for new empty deque populated with elements from slice.
func FromSlice(slice ()int) Deque {
    deq := New()
    for _, val := range slice {
        deq.Append(val)
    }
    return deq
}

// Append adds element to the end of the deque.
func (d *Deque) Append(elem int) {
    newNode := IntNode{value: elem, next: d.sentinel, prev: d.sentinel.prev}
    d.sentinel.prev.next = &newNode
    d.sentinel.prev = &newNode
    d.length += 1
}

// AppendLeft adds element to the front of the deque.
func (d *Deque) AppendLeft(elem int) {
    newNode := IntNode{value: elem, next: d.sentinel.next, prev: d.sentinel}
    d.sentinel.next.prev = &newNode
    d.sentinel.next = &newNode
    d.length += 1
}

// Pop removes and returns last element in deque.
func (d *Deque) Pop() int {
    if d.Empty() {
        panic("popping from empty list")
    }
    value := d.sentinel.prev.value
    d.sentinel.prev.prev.next = d.sentinel
    d.sentinel.prev = d.sentinel.prev.prev
    d.length -= 1
    return value
}

// Pop removes and returns first element in deque.
func (d *Deque) PopLeft() int {
    if d.Empty() {
        panic("popping from empty list")
    }
    value := d.sentinel.next.value
    d.sentinel.next.next.prev = d.sentinel
    d.sentinel.next = d.sentinel.next.next
    d.length -= 1
    return value
}

// Last return value of the first element in deque.
func (d *Deque) First() int {
    return d.sentinel.next.value
}

// Last return value of the last element in deque.
func (d *Deque) Last() int {
    return d.sentinel.prev.value
}

// Length returns number of elements in deque.
func (d *Deque) Length() int {
    return d.length
}

// Empty checks if there are any elements in deque.
func (d *Deque) Empty() bool {
    return d.length == 0
}

// String outputs string representation of deque.
func (d *Deque) String() string {
    var b strings.Builder
    curr := d.sentinel.next
    b.WriteString("Deque{")
    for i := 0; i < d.Length(); i++ {
        b.WriteString(strconv.Itoa(curr.value))
        b.WriteString(",")
        curr = curr.next
    }
    b.WriteString("}")
    return b.String()
}

// Equals checks if both deques contain same elements in the same order.
func (d *Deque) Equals(other *Deque) bool {
    if d.Length() != other.Length() {
        return false
    }
    curr := d.sentinel.next
    otherCurr := other.sentinel.next
    for i := 0; i < d.Length(); i++ {
        if curr.value != otherCurr.value {
            return false
        }
        curr = curr.next
        otherCurr = otherCurr.next
    }
    return true
}

node.go

package deque

type IntNode struct {
    value int
    next  *IntNode
    prev  *IntNode
}

deque_test.go

package deque

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

func TestEquals(t *testing.T) {
    for _, tc := range TestCasesEquals {
        if tc.this.Equals(&tc.other) != tc.expected {
            t.Errorf(tc.msg)
        }
    }
}

func TestAppend(t *testing.T) {
    for _, tc := range TestCasesAppend {
        actual := tc.actual()
        if !actual.Equals(&tc.expected) {
            t.Errorf(tc.msg)
        }
    }
}

func TestAppendLeft(t *testing.T) {
    for _, tc := range TestCasesAppendLeft {
        actual := tc.actual()
        if !actual.Equals(&tc.expected) {
            t.Errorf(tc.msg, actual, tc.expected)
        }
    }
}

func TestPop(t *testing.T) {
    // Main test cases
    for _, tc := range TestCasesPop {
        deque, popped := tc.actual()
        if !deque.Equals(&tc.expectedDeque) || popped != tc.expectedPopped {
            t.Errorf(tc.msg)
        }
    }

    // Popping from empty list
    poppingEmpty := func() {
        d := FromSlice(()int{})
        d.Pop()
    }
    assert.Panics(t, poppingEmpty, "popping from empty deque")
}

func TestPopLeft(t *testing.T) {
    // Main test cases
    for _, tc := range TestCasesPopLeft {
        deque, popped := tc.actual()
        if !deque.Equals(&tc.expectedDeque) || popped != tc.expectedPopped {
            t.Errorf(tc.msg)
        }
    }

    // Popping from empty list
    poppingEmpty := func() {
        d := FromSlice(()int{})
        d.Pop()
    }
    assert.Panics(t, poppingEmpty, "popping from empty deque")
}

func TestString(t *testing.T) {
    d := New()
    if d.String() != "Deque{}" {
        t.Errorf("empty deque; got: %v", d.String())
    }

    d = FromSlice(()int{1, 2, 7, 4})
    if d.String() != "Deque{1,2,7,4,}" {
        t.Errorf("4 element deque; got: %v", d.String())
    }
}

test_cases.go

package deque

type TestCaseEquals struct {
    this     Deque
    other    Deque
    expected bool
    msg      string
}

var TestCasesEquals = ()TestCaseEquals{
    {
        this:     New(),
        other:    New(),
        expected: true,
        msg:      "two empty deques",
    },
    {
        this:     FromSlice(()int{1, 2, 3}),
        other:    FromSlice(()int{1, 2, 3}),
        expected: true,
        msg:      "two identical, 3-element deques",
    },
    {
        this:     FromSlice(()int{1, 2, 3}),
        other:    FromSlice(()int{1, 2, 4}),
        expected: false,
        msg:      "same length, last element mismatching",
    },
    {
        this:     FromSlice(()int{1, 2, 3}),
        other:    FromSlice(()int{1, 2}),
        expected: false,
        msg:      "different length, elements matching",
    },
}

type TestCaseAppend struct {
    actual   func() Deque
    expected Deque
    msg      string
}

var TestCasesAppend = ()TestCaseAppend{
    {
        actual: func() Deque {
            return New()
        },
        expected: New(),
        msg:      "2 empty deques",
    },
    {
        actual: func() Deque {
            d := New()
            d.Append(1)
            return d
        },
        expected: FromSlice(()int{1}),
        msg:      "adding one element to deque",
    },
    {
        actual: func() Deque {
            d := New()
            d.Append(1)
            d.Append(3)
            d.Append(5)
            d.Append(19)
            return d
        },
        expected: FromSlice(()int{1, 3, 5, 19}),
        msg:      "adding multiple elements to deque",
    },
}

var TestCasesAppendLeft = ()TestCaseAppend{
    {
        actual: func() Deque {
            d := New()
            d.AppendLeft(1)
            return d
        },
        expected: FromSlice(()int{1}),
        msg:      "adding one element to deque. Got: %v, Expected: %v",
    },
    {
        actual: func() Deque {
            d := New()
            d.AppendLeft(1)
            d.AppendLeft(3)
            d.AppendLeft(5)
            d.AppendLeft(19)
            return d
        },
        expected: FromSlice(()int{19, 5, 3, 1}),
        msg:      "adding multiple elements to deque. Got: %v, Expected: %v",
    },
}

type TestCasePop struct {
    actual         func() (Deque, int)
    expectedDeque  Deque
    expectedPopped int
    msg            string
}

var TestCasesPop = ()TestCasePop{
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1})
            val := d.Pop()
            return d, val
        },
        expectedDeque:  New(),
        expectedPopped: 1,
        msg:            "popping from deque with 1 element",
    },
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1, 2, 3})
            val := d.Pop()
            return d, val
        },
        expectedDeque:  FromSlice(()int{1, 2}),
        expectedPopped: 3,
        msg:            "popping from deque with 3 elements",
    },
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1, 2, 3})
            d.Pop()
            val := d.Pop()
            return d, val
        },
        expectedDeque:  FromSlice(()int{1}),
        expectedPopped: 2,
        msg:            "popping twice from deque with 3 elements",
    },
}

var TestCasesPopLeft = ()TestCasePop{
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1})
            val := d.PopLeft()
            return d, val
        },
        expectedDeque:  New(),
        expectedPopped: 1,
        msg:            "popping from deque with 1 element",
    },
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1, 2, 3})
            val := d.PopLeft()
            return d, val
        },
        expectedDeque:  FromSlice(()int{2, 3}),
        expectedPopped: 1,
        msg:            "popping from deque with 3 elements",
    },
    {
        actual: func() (Deque, int) {
            d := FromSlice(()int{1, 2, 3})
            d.PopLeft()
            val := d.PopLeft()
            return d, val
        },
        expectedDeque:  FromSlice(()int{3}),
        expectedPopped: 2,
        msg:            "popping twice from deque with 3 elements",
    },
}

```

dnd 5e – Can the Dispel Magic spell end the spell effect of a spell that already ended?

I realized I had this question at the very end of answering the following:

So I’ll just use the example there, wall of light for my example here.

Say wall of light is cast on somebody, they are blinded for 1 minute, but then the caster of wall of light drops their concentration on the spell while their target remains blinded. Can that target then be targeted with dispel magic? The dispel magic spell states:

Choose one creature, object, or magical effect within range. Any spell of 3rd level or lower on the target ends. For each spell of 4th level or higher on the target, make an ability check using your spellcasting ability. The DC equals 10 + the spell’s level. On a successful check, the spell ends.

And, to me, there is a magic effect in range: the blinded effect from wall of light but what is unclear to me is whether that counts as “any spell of [X] level or lower”. The spell already ended, so what happens in this case?


We already have a similar question:

But I believe the case of haste is a bit exceptional in that its effect only occurs once the spell ends and things like this can occur before the spell ends and then continue afterwards.

custom roms – Updater process ended with ERROR: 1 [TWRP]

I was using Pixel experience 10.0 on Redmi 5A (Riva) and I decided to clean install Pixel experience 11.0 today. But I’m getting the following error on TWRP.

Installing zip file '/sdcard/Pixel Experience Riva 11.0.zip'
Checking for Digest file...
assert failed: riva.verify_trustzone("TZ.BF.4.0.5-157266") == "1"
Updater process ended with ERROR: 1
Error installing zip file '/sdcard/Pixel Experience Riva 11.0.zip'
Updating partition details...
...done

Note that:

  • I formatted the device with TWRP and wiped System, Dalvik, Data, Cache partitions.
  • I was using Pixel Experience before and my Bootloader is unlocked.
  • Previous version of the ROM (Pixel experience 10.0) is installing successfully.
  • My TWRP version is 3.4.0-0, and latest version of TWRP (3.5.0_9-0) doesn’t support on the device.

immutability – Is there a better method to implement an immutable double ended queue, that uses two single link lists internally for the dequeue using C++?

I am writing an immutable interpreter in C++ for fun. Originally standard vectors and dequeues were used to create a double ended queue data type, but it was very slow, because each operation require a whole new copy of the original container to be created.

So it was redone using a custom immutable single linked node lists which only requires a single node to be recreated during each operation on list like data types. And a double ended queue was implemented using two of these single linked lists. While it doesn’t require the whole data type and each element to be copied during each operation. It does require a limited recreation of the data type during dequeue operations to rebalance the two lists, which is expensive.

Is there a more efficient, and less copy expensive method, that could have been used to implement the double ended queue? Which does not require rebalancing the lists, and the original data still remains immutable during each operation.

class list {

        let    _lead;
        let    _last;
        int_t  _size;

    public:

        list();
        list(const list& exp);
        list(let exp);
        virtual ~list();

        friend str_t           __type__(const list& self);
        friend bool_t            __is__(const list& self);
        friend real_t          __comp__(const list& self, const let& other);
        friend void             __str__(stream_t& out, const list& self);
        friend void            __repr__(stream_t& out, const list& self);

        friend int_t            __len__(const list& self);
        friend let             __lead__(const list& self);
        friend let             __last__(const list& self);
        friend let       __place_lead__(const list& self, const let& other);
        friend let       __shift_lead__(const list& self);
        friend let       __place_last__(const list& self, const let& other);
        friend let       __shift_last__(const list& self);
        friend let          __reverse__(const list& self);

    private:
        void  balance();
    };

    /********************************************************************************************/
    //
    //                               'list' Class Implimentation
    //
    /********************************************************************************************/

    list::list() : _lead(__node__()), _last(__node__()), _size(0) {
    }

    list::list(const list& exp) : _lead(exp._lead), _last(exp._last), _size(exp._size) {
    }

    list::list(let exp) : _lead(__node__()), _last(__node__()), _size(0) {
        
        while (exp.is()) {

            _lead = _lead.place_lead(pop_lead(exp));

            _size += 1;
        }

        balance();
    }

    list::~list() {
    }

    std::string __type__(const list& self) {
        return "list";
    }

    bool_t __is__(const list& self) {

        if (self._lead.is() || self._last.is()) {
            return true;
        }

        return false;
    }

    real_t __comp__(const list& self, const let& other) {

        const list* e = other.cast<list>();

        if (e) {

            if ((self._lead == e->_lead) && (self._last == e->_last)) {
                return 0.0;
            }
        }

        return NOT_A_NUMBER;
    }

    void __str__(stream_t& out, const list& self) {

        if (!__is__(self)) {
            out << "()";
            return;
        }

        out << "(";

        out << str(self._lead);

        if (self._last.is()) {

            if (self._lead.is()) {
                out << " ";
            }

            out << str(self._last.reverse());
        }

        out << ")";
    }

    void __repr__(stream_t& out, const list& self) {

        if (!__is__(self)) {
            out << "()";
            return;
        }

        out << "(";

        out << repr(self._lead);

        if (self._last.is()) {

            if (self._lead.is()) {
                out << " ";
            }

            out << repr(self._last.reverse());
        }

        out << ")";
    }

    int_t __len__(const list& self) {
        return self._size;
    }

    let __lead__(const list& self) {

        if (!self._lead.is()) {
            return self._last.lead();
        }

        return self._lead.lead();
    }

    let __last__(const list& self) {

        if (!self._last.is()) {
            return self._lead.lead();
        }

        return self._last.lead();
    }

    let __place_lead__(const list& self, const let& other) {

        if (other.is_nothing()) {
            return self;
        }

        list e = self;

        e._lead = e._lead.place_lead(other);

        e._size += 1;

        if (!e._last.is()) {
            e.balance();
        }

        return e;
    }

    let __shift_lead__(const list& self) {

        if (__len__(self) == 0) {
            return self;
        }

        list e = self;

        if (!e._lead.is()) {

            if (e._last.shift_lead().is()) {
                // Balance if _last has more than one element.
                e.balance();
            }
            else {
                e._last = e._last.shift_lead();
                return e;
            }
        }

        e._lead = e._lead.shift_lead();

        if (!e._lead.is()) {

            if (e._last.shift_lead().is()) {
                e.balance();
            }
        }

        return e;
    }

    let __place_last__(const list& self, const let& other) {

        if (other.is_nothing()) {
            return self;
        }

        list e = self;

        e._last = e._last.place_lead(other);

        e._size += 1;

        if (!e._lead.is()) {
            e.balance();
        }

        return e;
    }

    let __shift_last__(const list& self) {

        if (__len__(self) == 0) {
            return self;
        }

        list e = self;

        if (!e._last.is()) {

            if (e._lead.shift_lead().is()) {
                // Balance if _last has more than one element.
                e.balance();
            }
            else {
                e._lead = e._lead.shift_lead();
                return e;
            }
        }

        e._last = e._last.shift_lead();

        if (!e._last.is()) {

            if (e._lead.shift_lead().is()) {
                e.balance();
            }
        }

        return e;
    }

    let __reverse__(const list& self) {

        if (__len__(self) < 2) {
            return self;
        }

        list e;

        e._lead = self._last;
        e._last = self._lead;
        e._size = self._size;

        return e;
    }

    void list::balance() {

        // print("lead = " + str(_lead) + " : last = " + str(_last));

        bool_t flip = _last.is() && !_lead.is();

        if (flip) {
            std::swap(_lead, _last);
        }

        int_t i = _size < 2 ? 1 : _size / 2;

        _lead = _lead.reverse();
        _last = _last.reverse();

        while (i --> 0) {

            _last = _last.place_lead(_lead.lead());
            _lead = _lead.shift_lead();
        }

        _lead = _lead.reverse();
        _last = _last.reverse();

        if (flip) {
            std::swap(_lead, _last);
        }
    }
```

dnd 5e – How does concentration work when wild shape is ended through damage?

This is pretty simple, actually.

Whenever you take damage while
you are concentrating on a spell, you must make a
Constitution saving throw to maintain your concentration.
The DC equals 10 or half the damage you take,
whichever number is higher.

You make a Constitution saving throw “whenever you take damage”. So when you take 30 damage, you make a Constitution saving throw. Since you make this when you take the damage, you use the stats you have when you take the damage. So it will be a DC 15 Constitution saving throw which you make with a +5 bonus.

The same reasoning applies to the 60 damage case. So when you take 60 damage, you make a DC 30 Constitution saving throw using a +5 bonus. There is a caveat, though.

When
you
revert
to
your
normal
form,
you
return
to
the
number
of
hit
points
you
had
before
you
transformed.
However,
if
you
revert
as
a
result
of
dropping
to
0
hit
points,
any
excess
damage
carries
over
to
your
normal
form.
For
example,
if
you
take
10
damage
in
animal
form
and
have
only
1
hit
point
left,
you
revert
and
take
9
damage.

This suggests that the 30 carryover damage will count as being taken, so you’ll have to make another Constitution saving throw, this time at DC 15, using your own +0 modifier.

Open ended questions or not for screener surveys?

I am preparing my first screener survey to recruit some participants for an interview.

I am getting mixed views on if these questions should be open ended or not.

For example, I have the following questions:

  • How often do you shop in Townsworth High Street? (Daily, Weekly, Monthly, Never)
  • How often do you attend events in Townsworth? (Daily, Weekly, Monthly, Never)
  • Do you prefer to “shop local” or support local businesses than a high street chain? (yes, no) (although I know I shouldn’t have yes/no questions, but not sure how I can reword this to get people who prefer to shop locally in the interview)
  • How often do you read reviews about a shop before visiting? (Always, Sometimes, Less Often, Never)
  • How often do you read reviews about a product before purchasing? (Always, Sometimes, Less Often, Never)

Should some of these be open ended questions such as

  • Tell me about the events you attend in Townsworth
  • Tell me why you prefer to shop local than high street chains

Should I be using open ended questions in the screener survey or leave these until the actual interview?

The NN Group mentions having open ended questions:
https://www.nngroup.com/articles/screening-questions-select-research-participants/

Any advice would be great, thanks!

Selling – [Offer Ended] Google Drive Suite – $15 – Unlimited Storage — Custom Username – Not EDU – Lifetime – Safe | Proxies-free

Offer Ended

We are Seller of Google Suite And Cloud Services.

Our Google Accounts are “Not EDU email” , “Not Team Drive” & “Not Shared”.
Edu email accounts are disabled by school after some months without even informing. and stored data gets lost.
Our Google Suite Accounts will be never get disabled.

Our Google Suite Account is a Lifetime Business License account from our ‘Organisation Business Account’ with your desired username and name (any name of your choice).

Best for File Storage for long term.
We Provide Lifetime Safety Warranty for stored files.
We deliver accounts with your desired username in just 5 mins after payment.

Fresh New Genuine Account!
NO MONTHLY FEES! (Only 1 Time Payment of $15)
No Annual charges!
Not Shared!
Never expires!
Not Team Drive.
Not Edu email Account.
100% SAFE for Long Term Storage.

Custom Name for Username.
Instant Delivery.

– This service offers an UNLIMITED Google Drive account
Google Drive Unlimited Storage (Can store more than 100TB files)
Google Photos Unlimited Storage original image quality (high resolution)
Gmail Unlimited Space And much more
– Compatible with Drive File Stream, Backup and Sync and any third-party application
– Store any archive, access your data anywhere
– Home, Office or on the move with your phone or tablet
– Unlimited storage in cloud to store Movies, Music, files or any document which you want documents.
– Unlimited Team Drive supported.

* For One Time Payment You will get LifeTime Google Drive Storage Account.
* Best for File Storage for Long Term.
* Safe Google Drive Account
* Limited Time Offer
* Regular Price is $144 per year .
* Screenshot available at

Price: $15 (+ transaction fees) (Limited Time Offer)
Payment via
: PayPal (preferred), BTC, PayTM (India), WebMoney, & Debit/Credit Card (All country and currency supported).
Stock Ready
: 2000

Contact Us via –
Telegram: @fastservice_seller
Skype: live:.cid.bfd1215dcb3ddb58
Email: admin@fastservice.me

Message: u can also PM me

What we require?
– Your desired Username for new gsuite account
– Your desired Full Name (firstname + lastname) for new gsuite account

What you Get?
– Email Account (with your desired username and name) & Password.
– You can change your password anytime
– You can change recovery email
– You can change recovery number phone.
– You can set 2factor Auth.

Note:
1. Instant Delivery within 9 AM to 9 PM in IST ., We generally deliver within just 5 mins. But max delivery time can be upto 12 Hours.
2. Payment method is via PayPal, BTC, PayTM (India), WebMoney & Debit/Credit Card . (contact us if other method required.)
3. Kindly send $16.4 (transaction fees included) to my PayPal email “admin@fastservice.me” or BTC address: “31hkT9AkszX6UXk32Wdgnimfe2WKuPrn7a” . For other payment options contact us.
4. After Payment, Send us Screenshot of the Transaction (Transaction ID for bitcoin payments), along with your desired username, firstname and lastname for the new gsuite / gdrive account.
5. I will confirm and create your unlimited drive within 24 hours. Generally we deliver within 5 mins.
6. Excess pirated content or porns stored and shared on these account may lead to suspension of the same by Google itself. ( We do not take responsibility). But we can help you in Recovering of your Files stored in your disabled Google Drive account, No files will be lost. Contact us in these cases.
7. In case you forget your password or access to your account is lost., then we can help you to gain access again. Contact us in these cases.
8. Kindly leave a positive feedback for me in this thread after our transaction is completed.

————-
Here is list of all our services, we provide are –

1) Gsuite new account unlimited storage for lifetime (custom username) at $15 ( this post )
2) Gsuite new account (same as above but on your own website/domain after onetime setup fee of $10) at $15 each. (can also used as email hosting solution, it will cost cheaper for long term)
3) OneDrive 5TB lifetime storage business new account at $5 . (Gsuite and OneDrive can be activated on single email at total price of $20)
4) Gdrive unlimited storage space as separate drive in current gmail account for lifetime at $4 .
————-

For ordering accounts, contact us via Telegram or Email .

Thank you!