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