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