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