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