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