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