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