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