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