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