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