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