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