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