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