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