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