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