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