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