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