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