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