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