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