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