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