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