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