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