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